From a0fd710eff0952ba61532e1416b63f093850d0d5 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sat, 19 Sep 2026 21:18:43 -0700
Subject: [PATCH 01/26] kits: Super Mario, a System One harness plays a
 platform game in a browser you watch

The fifth kit. The harness is a fork of the systemone base with this kit's
instructions and one plugin: an MCP server (plugin/bin/mario-env) that opens
Full Screen Mario in a headless Chromium inside the deployment, reads the
game's own state each step and says it as literal sentences (where Mario is,
whether he is on the ground, the nearest enemy, gap and wall in tiles, what
one step reaches and what is within it), and acts by holding the keys the
game listens to. The keys are sticky: a run continues between decisions and
a jump keeps the run key down for the whole flight. Every step writes the
browser's frame to frame.jpg in the session workspace, and the page shows
it beside a panel that starts, streams, stops and continues the run.

Measured on the live model before this commit: 37 actions in 69 s, one
death, 47 game seconds played; earlier shapes of the state lost five to
seven lives in the same budget (jumping one step late, then braking
mid-air). The page-specific code is all in the plugin; the base knows
nothing about the game.

Credits in the kit's README and on the page: Full Screen Mario at
supermarioplay.com (none of its files ship here), Browser Use (MIT),
TypeSafe's Jev through OpenRouter.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits.json                             |  26 +-
 kits/mario/README.md                  |  37 +++
 kits/mario/app/app.css                |  38 +++
 kits/mario/app/app.js                 | 112 ++++++++
 kits/mario/app/icon.svg               |   7 +
 kits/mario/app/index.html             |  45 +++
 kits/mario/icon.svg                   |   7 +
 kits/mario/kit.json                   |  27 ++
 kits/mario/plugin/bin/mario-env       |  14 +
 kits/mario/plugin/mcp.json            |   6 +
 kits/mario/plugin/plugin.json         |   8 +
 kits/mario/plugin/server/mario_env.py | 396 ++++++++++++++++++++++++++
 12 files changed, 718 insertions(+), 5 deletions(-)
 create mode 100644 kits/mario/README.md
 create mode 100644 kits/mario/app/app.css
 create mode 100644 kits/mario/app/app.js
 create mode 100644 kits/mario/app/icon.svg
 create mode 100644 kits/mario/app/index.html
 create mode 100644 kits/mario/icon.svg
 create mode 100644 kits/mario/kit.json
 create mode 100755 kits/mario/plugin/bin/mario-env
 create mode 100644 kits/mario/plugin/mcp.json
 create mode 100644 kits/mario/plugin/plugin.json
 create mode 100644 kits/mario/plugin/server/mario_env.py

diff --git a/kits.json b/kits.json
index d9bc893..19b98b6 100644
--- a/kits.json
+++ b/kits.json
@@ -6,16 +6,32 @@
     "that talks to that Harness as its backend. Launching one provisions the Harness and opens",
     "the app; there is no separate service to deploy and no database to configure.",
     "",
-    "include        — build this kit into the image. false leaves it in the repo and out of the",
+    "include        \u2014 build this kit into the image. false leaves it in the repo and out of the",
     "                 image, which is how a kit under development stays unshipped.",
     "",
     "Everything else a kit needs lives in kits/<name>/kit.json, next to the code it describes,",
     "so adding a kit does not mean editing this file beyond one line."
   ],
   "kits": [
-    { "name": "slides", "include": true },
-    { "name": "sheets", "include": true },
-    { "name": "dashboard", "include": true },
-    { "name": "video", "include": true }
+    {
+      "name": "slides",
+      "include": true
+    },
+    {
+      "name": "sheets",
+      "include": true
+    },
+    {
+      "name": "dashboard",
+      "include": true
+    },
+    {
+      "name": "video",
+      "include": true
+    },
+    {
+      "name": "mario",
+      "include": true
+    }
   ]
 }
diff --git a/kits/mario/README.md b/kits/mario/README.md
new file mode 100644
index 0000000..cbceb11
--- /dev/null
+++ b/kits/mario/README.md
@@ -0,0 +1,37 @@
+# Super Mario kit
+
+A System One model plays a platform game, several decisions a second, and you watch the browser
+it plays in.
+
+## How it is put together
+
+- **The harness** is a fork of the `systemone` base (the open-source
+  [System One Harness](https://github.com/HarnessRouter/SystemOneHarness)) with this kit's
+  instructions and one plugin.
+- **The plugin** (`plugin/`) ships an MCP server, `bin/mario-env`, that is the environment: it
+  opens the game in a headless Chromium inside the deployment, reads the game's own state each step
+  and says it as short literal sentences (where Mario is, whether he is on the ground, the nearest
+  enemy, gap and wall with distances in tiles), and acts by holding the keys the game listens to
+  (`run_right`, `jump_right`, `jump`, `walk_left`, `wait`, each with a hold length). The model never
+  sees a pixel and never writes text; it chooses.
+- **The page** (`app/`) shows `frame.jpg`, which the environment writes into the session's
+  workspace on every step, so the left pane is the model's own game, not a copy. The right pane
+  starts a run, streams every action with the game's reply and the step's latency, and can stop or
+  continue it.
+
+The base is general and knows nothing about this game; everything about the game lives in this
+kit's plugin, which is what a fork of a base is for.
+
+## Credits
+
+- The game is **Full Screen Mario**, played at [supermarioplay.com](https://supermarioplay.com/game/mario.html?v=1.0.1).
+  Mario and its characters belong to Nintendo; this kit plays the page as a person would and ships
+  none of the game's files.
+- The browser is driven with [Browser Use](https://github.com/browser-use/browser-use) (MIT) over the
+  Chrome DevTools Protocol.
+- The model is [Jev](https://typesafe.ai) by TypeSafe, a System One model, reached through OpenRouter.
+
+## Running it
+
+Launch the kit from Starter Kits with an OpenRouter key connected. The first launch on a fresh
+install adds a Chromium beside the System One base (about a minute). Then press Start.
diff --git a/kits/mario/app/app.css b/kits/mario/app/app.css
new file mode 100644
index 0000000..63a1617
--- /dev/null
+++ b/kits/mario/app/app.css
@@ -0,0 +1,38 @@
+:root { color-scheme: light dark; font: 14px/1.45 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; --accent: #E4572E; }
+* { box-sizing: border-box; }
+body { margin: 0; min-height: 100vh; display: flex; flex-direction: column; }
+.top { display: flex; align-items: center; justify-content: space-between; padding: 10px 16px; border-bottom: 1px solid #8883; }
+.brand { display: flex; align-items: center; gap: 10px; }
+.brand img { border-radius: 6px; }
+h1 { font-size: 16px; margin: 0; }
+.panes { display: grid; grid-template-columns: minmax(0, 1.6fr) minmax(320px, 1fr); gap: 0; flex: 1; min-height: 0; }
+.stage { padding: 16px; border-right: 1px solid #8883; display: flex; flex-direction: column; gap: 12px; min-width: 0; }
+.frame-box { position: relative; width: 100%; aspect-ratio: 16 / 10; background: #101828; border-radius: 10px; overflow: hidden; display: flex; align-items: center; justify-content: center; }
+.frame-box img { width: 100%; height: 100%; object-fit: contain; display: block; image-rendering: pixelated; }
+.frame-note { color: #cbd5e1; padding: 24px; text-align: center; max-width: 36ch; }
+.credits { color: #888; font-size: 12px; margin: 0; }
+.credits a { color: inherit; }
+.panel { padding: 16px; display: flex; flex-direction: column; gap: 8px; min-width: 0; overflow: auto; }
+label { font-weight: 600; margin-top: 4px; }
+textarea { width: 100%; font: inherit; padding: 8px; border: 1px solid #8884; border-radius: 8px; background: transparent; color: inherit; resize: vertical; }
+button { font: inherit; padding: 7px 14px; border-radius: 8px; border: 1px solid #8886; background: var(--accent); color: #fff; cursor: pointer; }
+button[disabled] { opacity: .5; cursor: default; }
+button.stop { background: #b91c1c; }
+button.quiet { background: transparent; color: inherit; }
+.row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+.between { justify-content: space-between; }
+.note { color: #888; margin: 0; }
+.pill { font-size: 11px; padding: 2px 8px; border-radius: 999px; border: 1px solid #8886; }
+.pill.ok { border-color: #16a34a; color: #16a34a; }
+.pill.running { border-color: var(--accent); color: var(--accent); }
+.pill.bad { border-color: #b91c1c; color: #b91c1c; }
+ol#steps { padding-left: 20px; margin: 4px 0; }
+ol#steps li { margin: 5px 0; }
+.action { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; }
+.result { color: #777; }
+.reason { color: #8a6d00; font-style: italic; }
+.final { font-weight: 600; }
+@media (max-width: 860px) {
+  .panes { grid-template-columns: 1fr; }
+  .stage { border-right: 0; border-bottom: 1px solid #8883; }
+}
diff --git a/kits/mario/app/app.js b/kits/mario/app/app.js
new file mode 100644
index 0000000..2313e8f
--- /dev/null
+++ b/kits/mario/app/app.js
@@ -0,0 +1,112 @@
+// The kit's page is a plain Unified Harness Protocol client, same-origin with the console's API
+// proxy: start a run on this kit's harness, stream its items, show the frame the environment
+// writes into the session's workspace. Every number shown comes from the server's own events.
+const $ = (id) => document.getElementById(id);
+const API = '/api/harness/v1';
+const state = { harness: null, responseId: null, sessionId: null, controller: null, startedAt: 0, frameTimer: null };
+const esc = (s) => String(s ?? '').replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c]));
+
+function setStatus(text, cls) { const s = $('status'); s.textContent = text; s.className = 'pill' + (cls ? ' ' + cls : ''); }
+function addStep(html, cls) {
+  const li = document.createElement('li'); li.className = cls || ''; li.innerHTML = html; $('steps').appendChild(li);
+  li.scrollIntoView({ block: 'nearest' });
+}
+
+async function harness() {
+  if (state.harness) return state.harness;
+  const r = await fetch(`${API}/harnesses`, { cache: 'no-store' });
+  if (!r.ok) throw new Error(`could not list harnesses (${r.status})`);
+  const { harnesses = [] } = await r.json();
+  state.harness = harnesses.find((h) => h.kit === 'mario') || null;
+  if (!state.harness) throw new Error('Super Mario has not been launched yet. Open Starter Kits and launch it.');
+  $('harnessName').textContent = state.harness.name || 'Super Mario';
+  $('harnessModel').textContent = state.harness.defaultModel || state.harness.default_model || '';
+  return state.harness;
+}
+
+function pollFrame() {
+  if (!state.sessionId) return;
+  const img = $('frame');
+  const next = () => { state.frameTimer = setTimeout(pollFrame, 180); };
+  const url = `${API}/sessions/${encodeURIComponent(state.sessionId)}/files/frame.jpg?t=${Date.now()}`;
+  const probe = new Image();
+  probe.onload = () => { img.src = probe.src; img.hidden = false; $('frameNote').hidden = true; next(); };
+  probe.onerror = next;
+  probe.src = url;
+}
+function stopFrames() { if (state.frameTimer) clearTimeout(state.frameTimer); state.frameTimer = null; }
+
+async function start(previous) {
+  const goal = $('goal').value.trim();
+  if (!goal) { $('taskNote').textContent = 'Give the run a goal.'; return; }
+  let h;
+  try { h = await harness(); } catch (e) { $('taskNote').textContent = e.message; return; }
+  const body = { input: goal, stream: true, metadata: { harness_id: h.id } };
+  if (previous) body.previous_response_id = previous;
+  $('steps').innerHTML = ''; $('final').hidden = true; $('traceMeta').textContent = ''; $('taskNote').textContent = '';
+  $('startBtn').disabled = true; $('cancelBtn').hidden = false; $('continueBtn').hidden = true;
+  setStatus('running', 'running');
+  state.controller = new AbortController(); state.startedAt = performance.now();
+  let calls = 0;
+  try {
+    const r = await fetch(`${API}/responses`, { method: 'POST', headers: { 'content-type': 'application/json', accept: 'text/event-stream' },
+      body: JSON.stringify(body), signal: state.controller.signal, cache: 'no-store' });
+    if (!r.ok) throw new Error(`${r.status} ${(await r.text()).slice(0, 200)}`);
+    const reader = r.body.getReader(); const dec = new TextDecoder(); let buf = '';
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf('\n\n')) >= 0) {
+        const chunk = buf.slice(0, nl); buf = buf.slice(nl + 2);
+        for (const line of chunk.split('\n')) {
+          if (!line.startsWith('data: ')) continue;
+          let ev; try { ev = JSON.parse(line.slice(6)); } catch { continue; }
+          handle(ev);
+        }
+      }
+    }
+  } catch (e) {
+    if (e.name !== 'AbortError') { setStatus('failed', 'bad'); $('taskNote').textContent = e.message; }
+  } finally {
+    $('startBtn').disabled = false; $('cancelBtn').hidden = true;
+    if (state.responseId) $('continueBtn').hidden = false;
+    setTimeout(stopFrames, 1500);
+  }
+
+  function handle(ev) {
+    const t = ev.type;
+    if (t === 'response.created') {
+      state.responseId = ev.response.id;
+      const sid = ev.response.metadata?.session_id || null;
+      if (sid && sid !== state.sessionId) { state.sessionId = sid; stopFrames(); pollFrame(); }
+      $('traceTitle').textContent = `Steps · ${state.responseId.slice(0, 12)}…`;
+      return;
+    }
+    if (t === 'response.output_item.done') {
+      const it = ev.item; const ms = Math.round(performance.now() - state.startedAt);
+      if (it.type === 'function_call') { calls += 1; addStep(`<span class="action">${esc(it.name)}(${esc(it.arguments)})</span> <span class="note">${ms} ms</span>`); }
+      else if (it.type === 'function_call_output') addStep(`<span class="result">${esc(it.output)}</span>`);
+      else if (it.type === 'reasoning') addStep(`<span class="reason">${esc((it.summary || [])[0]?.text || '')}</span>`);
+      else if (it.type === 'message') { $('final').textContent = (it.content || [])[0]?.text || ''; $('final').hidden = false; }
+      return;
+    }
+    if (t === 'response.completed' || t === 'response.incomplete' || t === 'response.failed') {
+      const r = ev.response; const u = r.usage; const secs = ((performance.now() - state.startedAt) / 1000).toFixed(1);
+      setStatus(r.status + (r.incomplete_details?.reason ? `: ${r.incomplete_details.reason}` : ''), r.status === 'completed' ? 'ok' : 'bad');
+      $('traceMeta').textContent = `${calls} action${calls === 1 ? '' : 's'} · ${secs} s` + (u ? ` · ${u.input_tokens} in / ${u.output_tokens} out` : '') + (r.model ? ` · ${r.model}` : '');
+      if (r.error) $('taskNote').textContent = r.error.message || JSON.stringify(r.error);
+    }
+  }
+}
+
+async function cancel() {
+  if (!state.responseId) return;
+  try { await fetch(`${API}/responses/${encodeURIComponent(state.responseId)}/cancel`, { method: 'POST' }); } catch {}
+}
+
+$('startBtn').addEventListener('click', () => start(null));
+$('continueBtn').addEventListener('click', () => start(state.responseId));
+$('cancelBtn').addEventListener('click', cancel);
+harness().catch((e) => { $('taskNote').textContent = e.message; });
diff --git a/kits/mario/app/icon.svg b/kits/mario/app/icon.svg
new file mode 100644
index 0000000..019c875
--- /dev/null
+++ b/kits/mario/app/icon.svg
@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Super Mario kit">
+  <rect width="64" height="64" rx="14" fill="#E4572E"/>
+  <rect x="14" y="36" width="36" height="14" rx="3" fill="#7A2E12"/>
+  <rect x="24" y="16" width="16" height="20" rx="4" fill="#FFE8D6"/>
+  <rect x="20" y="12" width="24" height="8" rx="3" fill="#B71C1C"/>
+  <circle cx="29" cy="25" r="2" fill="#1F1F1F"/><circle cx="35" cy="25" r="2" fill="#1F1F1F"/>
+</svg>
diff --git a/kits/mario/app/index.html b/kits/mario/app/index.html
new file mode 100644
index 0000000..06687d9
--- /dev/null
+++ b/kits/mario/app/index.html
@@ -0,0 +1,45 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Super Mario</title>
+<link rel="stylesheet" href="/kits/mario/app.css">
+</head>
+<body>
+<header class="top">
+  <div class="brand"><img src="/kits/mario/icon.svg" alt="" width="28" height="28"><h1>Super Mario</h1></div>
+  <span id="status" class="pill">ready</span>
+</header>
+<main class="panes">
+  <section class="stage">
+    <div class="frame-box">
+      <img id="frame" alt="The frame of the browser the model is playing in" hidden>
+      <div id="frameNote" class="frame-note">Press Start. The frame of the browser the model plays in appears here, written by the environment on every step.</div>
+    </div>
+    <p class="credits">The game is <a href="https://supermarioplay.com/game/mario.html?v=1.0.1" target="_blank" rel="noopener">Full Screen Mario at supermarioplay.com</a>; Mario belongs to Nintendo and none of the game's files ship here. The browser is driven with <a href="https://github.com/browser-use/browser-use" target="_blank" rel="noopener">Browser Use</a> (MIT). The model is <a href="https://typesafe.ai" target="_blank" rel="noopener">Jev</a> by TypeSafe, a System One model, through OpenRouter. The harness is the open-source <a href="https://github.com/HarnessRouter/SystemOneHarness" target="_blank" rel="noopener">System One Harness</a>.</p>
+  </section>
+  <section class="panel">
+    <div class="row between">
+      <strong id="harnessName">Super Mario</strong>
+      <span id="harnessModel" class="note"></span>
+    </div>
+    <label for="goal">Goal</label>
+    <textarea id="goal" rows="2">Play the level: keep running right, jump over enemies, gaps and pipes, and get as far as you can.</textarea>
+    <div class="row">
+      <button id="startBtn">Start</button>
+      <button id="cancelBtn" class="stop" hidden>Stop</button>
+      <button id="continueBtn" class="quiet" hidden>Continue</button>
+    </div>
+    <p id="taskNote" class="note"></p>
+    <div class="row between">
+      <strong id="traceTitle">Steps</strong>
+      <span id="traceMeta" class="note"></span>
+    </div>
+    <ol id="steps"></ol>
+    <p id="final" class="final" hidden></p>
+  </section>
+</main>
+<script src="/kits/mario/app.js"></script>
+</body>
+</html>
diff --git a/kits/mario/icon.svg b/kits/mario/icon.svg
new file mode 100644
index 0000000..019c875
--- /dev/null
+++ b/kits/mario/icon.svg
@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Super Mario kit">
+  <rect width="64" height="64" rx="14" fill="#E4572E"/>
+  <rect x="14" y="36" width="36" height="14" rx="3" fill="#7A2E12"/>
+  <rect x="24" y="16" width="16" height="20" rx="4" fill="#FFE8D6"/>
+  <rect x="20" y="12" width="24" height="8" rx="3" fill="#B71C1C"/>
+  <circle cx="29" cy="25" r="2" fill="#1F1F1F"/><circle cx="35" cy="25" r="2" fill="#1F1F1F"/>
+</svg>
diff --git a/kits/mario/kit.json b/kits/mario/kit.json
new file mode 100644
index 0000000..be82ce2
--- /dev/null
+++ b/kits/mario/kit.json
@@ -0,0 +1,27 @@
+{
+  "id": "mario",
+  "title": "Super Mario",
+  "tagline": "A System One model plays a platform game several times a second, and you watch its browser.",
+  "description": "Full Screen Mario runs in a headless browser inside this deployment. The System One base reads the game's own state each step as a few literal sentences (where Mario is, what is ahead and how far) and chooses one control to hold, a few hundred milliseconds a decision, with no screenshot and no text generation. The left pane shows the frame of the browser the model is playing in; the right pane is the harness. Credits: the game is Full Screen Mario, played at supermarioplay.com; the browser is driven with Browser Use (MIT); the model is TypeSafe's Jev through OpenRouter.",
+  "icon": "tabler:device-gamepad-2",
+  "accent": "#E4572E",
+  "harness": {
+    "name": "Super Mario",
+    "base": "systemone",
+    "recommended": [
+      { "base": "systemone", "model": "jev-1.13" },
+      { "base": "systemone", "model": "jev-latest" }
+    ],
+    "plugin": "plugin",
+    "mcp_servers": [],
+    "system_prompt": "You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. Keep moving right. Jump over an enemy when it is within 3 tiles, over a gap when its edge is within 2 tiles, and over a pipe or wall when it is within 2 tiles; hold the jump longer for a taller wall or a wider gap. Finish when the level is cleared. Escalate when Mario has no lives left."
+  },
+  "app": {
+    "route": "/kits/mario"
+  },
+  "session": {
+    "$comment": "One session is one run of the game. The frame the page shows is frame.jpg in the session's workspace, written by the environment on every step.",
+    "artifact": "frame.jpg",
+    "title_from": "meta.title"
+  }
+}
diff --git a/kits/mario/plugin/bin/mario-env b/kits/mario/plugin/bin/mario-env
new file mode 100755
index 0000000..6b7c362
--- /dev/null
+++ b/kits/mario/plugin/bin/mario-env
@@ -0,0 +1,14 @@
+#!/bin/sh
+# The game environment, started by the runner as the harness's MCP server for a turn. It runs on
+# the System One base's own Python (the venv the image installs for that base, which carries
+# browser-use and the MCP SDK) and on the Chromium installed beside it; outside the image, any
+# python3 with `systemone-harness[browser]` and a Chrome on the machine will do.
+here="$(cd "$(dirname "$0")/.." && pwd)"
+py=python3
+for cand in /data/agent-tools/systemone-venv/bin/python "$HOME/.systemone-venv/bin/python"; do
+  if [ -x "$cand" ]; then py="$cand"; break; fi
+done
+if [ -z "$PLAYWRIGHT_BROWSERS_PATH" ] && [ -d /data/agent-tools/ms-playwright ]; then
+  export PLAYWRIGHT_BROWSERS_PATH=/data/agent-tools/ms-playwright
+fi
+exec "$py" "$here/server/mario_env.py"
diff --git a/kits/mario/plugin/mcp.json b/kits/mario/plugin/mcp.json
new file mode 100644
index 0000000..5df1052
--- /dev/null
+++ b/kits/mario/plugin/mcp.json
@@ -0,0 +1,6 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {
+    "mario": { "type": "stdio", "command": "./bin/mario-env" }
+  }
+}
diff --git a/kits/mario/plugin/plugin.json b/kits/mario/plugin/plugin.json
new file mode 100644
index 0000000..7bceaab
--- /dev/null
+++ b/kits/mario/plugin/plugin.json
@@ -0,0 +1,8 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "mario-env",
+  "version": "0.1.0",
+  "description": "Full Screen Mario as an environment for the System One base: the game's state as literal text each step, the keys it listens to as actions, and the browser's frame for the page to show.",
+  "homepage": "https://github.com/HarnessRouter/starter-kit",
+  "license": "SEE LICENSE IN ../LICENSE.md"
+}
diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
new file mode 100644
index 0000000..a937446
--- /dev/null
+++ b/kits/mario/plugin/server/mario_env.py
@@ -0,0 +1,396 @@
+"""The game as an environment for a System One harness: an MCP server over a headless Chrome.
+
+This is the page-specific half of the kit, and the only page-specific code there is. It opens
+Full Screen Mario (played at supermarioplay.com) in a browser it controls over the DevTools
+Protocol, reads the game's own state each step and says it as short literal sentences (where
+Mario is, whether he is on the ground, what is ahead and how far, in tiles), and acts by holding
+the keys the game listens to. The System One base compiles these tools into its action space; the
+model chooses among them, several times a second, and never sees a pixel.
+
+Every step also writes the browser's current frame to `frame.jpg` at the workspace root, which
+the kit's page shows: what the person watches is the browser the model is playing in.
+
+State definition convention (systemone_harness/tools.py): `observe` and `reset` are the protocol,
+every other tool an action whose parameters are enumerable. The browser is Browser Use's session
+(browser-use, MIT) over a Chromium the image installs for the base.
+"""
+
+import asyncio
+import glob
+import os
+import pathlib
+import shutil
+import sys
+import threading
+import time
+from typing import Annotated
+
+from pydantic import Field
+
+GAME_URL = os.environ.get("MARIO_URL", "https://supermarioplay.com/game/mario.html?v=1.0.1")
+TILE = 8                      # game units per tile; the game draws a tile as 8 * unitsize px
+HOLDS = {"short": 0.15, "medium": 0.35, "long": 0.6}
+KEY = {"left": 37, "right": 39, "jump": 38, "down": 40, "sprint": 16}
+ITEMS = {"Coin", "Mushroom", "FireFlower", "Star", "Vine", "Text", "Shell", "Fireball"}
+INSTRUCTIONS = ("You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on "
+                "the ground, and what is ahead with distances in tiles. One step lasts about half a second and "
+                "covers up to 4 tiles at a run. Keep moving right. The state names any enemy, gap or wall that is "
+                "within one step: jump over it now, with jump_right; hold the jump longer for a taller wall or a "
+                "wider gap. Otherwise run right. When Mario has just died, wait. Finish when the level is cleared. "
+                "Escalate when Mario has no lives left.")
+
+STATE_JS = """(function(){
+  if (!window.player || !window.gamescreen) return {ready: false};
+  var u = window.unitsize || 4, T = 8 * u, p = player, sl = gamescreen.left, sr = gamescreen.right;
+  function tiles(px){ return Math.round(px / T * 10) / 10; }
+  var enemies = [], gaps = [], walls = [];
+  (window.characters || []).forEach(function(c){
+    if (!c.alive || c === player || c.title === undefined) return;
+    if (['Coin','Mushroom','FireFlower','Star','Vine','Text','Shell','Fireball'].indexOf(c.title) >= 0) return;
+    var dx = (c.left - p.right) / T, dy = (p.bottom - c.bottom) / T;
+    if (dx >= 0 && dx <= 12) enemies.push({kind: c.title, dx: Math.round(dx * 10) / 10, dy: Math.round(dy * 10) / 10});
+  });
+  var floors = (window.solids || []).filter(function(s){ return s.alive && s.title === 'Floor' && s.top >= p.bottom - 4; });
+  var x = p.right, gapStart = null;
+  for (var i = 0; i <= 12 * T; i += T / 4) {
+    var covered = floors.some(function(f){ return f.left <= x + i && x + i <= f.right; });
+    if (!covered && gapStart === null) gapStart = i;
+    if (covered && gapStart !== null) { gaps.push({dx: tiles(gapStart), width: tiles(i - gapStart)}); gapStart = null; }
+  }
+  if (gapStart !== null) gaps.push({dx: tiles(gapStart), width: tiles(12 * T - gapStart)});
+  (window.solids || []).forEach(function(s){
+    if (!s.alive || ['Pipe','Block','Brick','Stone'].indexOf(s.title) < 0) return;
+    var dx = (s.left - p.right) / T;
+    if (dx >= 0 && dx <= 8 && s.bottom > p.top - T && s.top < p.bottom) {
+      walls.push({kind: s.title.toLowerCase(), dx: Math.round(dx * 10) / 10, height: tiles(p.bottom - s.top)});
+    }
+  });
+  enemies.sort(function(a, b){ return a.dx - b.dx; }); walls.sort(function(a, b){ return a.dx - b.dx; }); gaps.sort(function(a, b){ return a.dx - b.dx; });
+  var d = window.data || {};
+  function amt(k){ return d[k] && d[k].amount !== undefined ? d[k].amount : null; }
+  return {ready: true, x: tiles(p.left), y: tiles((window.map && map.floor ? map.floor * u : p.bottom) - p.bottom),
+          dying: !!p.dying,
+          screen_tiles: tiles(sr - sl), xvel: Math.round((p.xvel || 0) * 10) / 10, on_ground: !!p.resting, dead: !!p.dead,
+          power: p.power || 1, enemies: enemies.slice(0, 3), gaps: gaps.slice(0, 2), walls: walls.slice(0, 2),
+          lives: amt('lives'), time: amt('time'), score: amt('score'), world: amt('world'), paused: !!window.paused,
+          ending: !!(window.map && map.ending)};
+})()"""
+
+
+def find_chrome() -> str | None:
+    """A Chromium to launch: the one named, the base's Playwright install, or a system Chrome."""
+    for env in ("MARIO_CHROME", "S1_CHROME"):
+        if os.environ.get(env) and os.path.exists(os.environ[env]):
+            return os.environ[env]
+    roots = [os.environ.get("PLAYWRIGHT_BROWSERS_PATH"), "/data/agent-tools/ms-playwright",
+             os.path.expanduser("~/.cache/ms-playwright")]
+    for root in roots:
+        if not root:
+            continue
+        for pat in ("chromium-*/chrome-linux*/chrome", "chromium-*/chrome-mac*/Chromium.app/Contents/MacOS/Chromium",
+                    "chromium_headless_shell-*/chrome-linux*/headless_shell"):
+            hits = sorted(glob.glob(os.path.join(root, pat)))
+            if hits:
+                return hits[-1]
+    for p in ("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/usr/bin/google-chrome",
+              "/usr/bin/chromium", "/usr/bin/chromium-browser"):
+        if os.path.exists(p):
+            return p
+    return shutil.which("google-chrome") or shutil.which("chromium") or None
+
+
+def workspace_root() -> pathlib.Path:
+    """Where the kit's page reads the frame from: the session workspace, three levels above the
+    plugin root the runner materialised (.harness/plugins/<name>)."""
+    root = os.environ.get("PLUGIN_ROOT")
+    if root:
+        return pathlib.Path(root).resolve().parents[2]
+    return pathlib.Path.cwd()
+
+
+class Game:
+    def __init__(self):
+        self._loop = asyncio.new_event_loop()
+        threading.Thread(target=self._loop.run_forever, daemon=True, name="mario-loop").start()
+        self._session = None
+        self._cdp = None
+        self.frame_path = workspace_root() / "frame.jpg"
+        self.started_at = time.time()
+        self.steps = 0
+        self._lives = None
+        self._restarting_until = 0.0
+        self._held: set[int] = set()
+
+    def _run(self, coro, timeout: float = 120.0):
+        return asyncio.run_coroutine_threadsafe(coro, self._loop).result(timeout)
+
+    async def _start(self):
+        if self._session is not None:
+            return
+        from browser_use.browser import BrowserProfile, BrowserSession
+        chrome = find_chrome()
+        if not chrome:
+            raise RuntimeError("no Chromium to launch: set PLAYWRIGHT_BROWSERS_PATH or MARIO_CHROME")
+        profile = BrowserProfile(headless=True, executable_path=chrome, user_data_dir=None,
+                                 viewport={"width": 960, "height": 600}, window_size={"width": 960, "height": 600})
+        self._session = BrowserSession(browser_profile=profile)
+        await self._session.start()
+        await self._session.navigate_to(GAME_URL)
+        self._cdp = await self._session.get_or_create_cdp_session()
+        for _ in range(80):
+            st = await self._eval(STATE_JS)
+            if isinstance(st, dict) and st.get("ready"):
+                break
+            await asyncio.sleep(0.25)
+        await self._eval("window.unpause && unpause(); 'ok'")
+
+    async def _eval(self, expression: str):
+        r = await self._cdp.cdp_client.send.Runtime.evaluate(params={"expression": expression, "returnByValue": True},
+                                                             session_id=self._cdp.session_id)
+        return (r.get("result") or {}).get("value")
+
+    async def _frame(self) -> None:
+        try:
+            r = await self._cdp.cdp_client.send.Page.captureScreenshot(params={"format": "jpeg", "quality": 45},
+                                                                       session_id=self._cdp.session_id)
+            import base64
+            data = base64.b64decode(r["data"])
+            tmp = self.frame_path.with_suffix(".jpg.tmp")
+            tmp.write_bytes(data)
+            os.replace(tmp, self.frame_path)
+        except Exception:  # noqa: BLE001 - a missed frame is a missed frame, never a failed step
+            pass
+
+    async def _down(self, *codes: int) -> None:
+        for c in codes:
+            if c not in self._held:
+                await self._eval(f"keydown({c}); 'ok'")
+                self._held.add(c)
+
+    async def _up(self, *codes: int) -> None:
+        for c in codes:
+            if c in self._held:
+                await self._eval(f"keyup({c}); 'ok'")
+                self._held.discard(c)
+
+    async def _macro(self, name: str, hold: float) -> None:
+        """The keys stay where a macro leaves them: running stays running between decisions, and a
+        jump keeps the run key down for the whole flight. Releasing everything after each hold
+        left Mario braking mid-air and landing short of the enemy he had jumped for (measured:
+        five deaths in twenty-nine actions with released keys)."""
+        R, S, U, L = KEY["right"], KEY["sprint"], KEY["jump"], KEY["left"]
+        if name == "run_right":
+            await self._up(L)
+            await self._down(R, S)
+            await asyncio.sleep(hold)
+        elif name == "jump_right":
+            await self._up(L)
+            await self._down(R, S)
+            await self._eval(f"keydown({U}); 'ok'")
+            await asyncio.sleep(hold)
+            await self._eval(f"keyup({U}); 'ok'")
+            await asyncio.sleep(max(0.0, 0.75 - hold))      # the flight, run key still down
+        elif name == "jump":
+            await self._up(R, S, L)
+            await self._eval(f"keydown({U}); 'ok'")
+            await asyncio.sleep(hold)
+            await self._eval(f"keyup({U}); 'ok'")
+            await asyncio.sleep(max(0.0, 0.6 - hold))
+        elif name == "walk_left":
+            await self._up(R, S)
+            await self._down(L)
+            await asyncio.sleep(hold)
+            await self._up(L)
+        else:
+            await self._up(R, S, L)
+            await asyncio.sleep(0.25)
+
+    # ── the tools ──
+    def reset(self, goal: str) -> dict:
+        async def go():
+            await self._start()
+            await self._session.navigate_to(GAME_URL)
+            for _ in range(80):
+                st = await self._eval(STATE_JS)
+                if isinstance(st, dict) and st.get("ready"):
+                    break
+                await asyncio.sleep(0.25)
+            await self._eval("window.unpause && unpause(); 'ok'")
+            await self._frame()
+            return {"ok": True}
+        self.steps = 0
+        return self._run(go())
+
+    def observe(self) -> dict:
+        async def go():
+            await self._start()
+            st = await self._eval(STATE_JS)
+            await self._frame()
+            return st if isinstance(st, dict) else {"ready": False}
+        st = self._run(go())
+        return self._describe(st)
+
+    async def _settled(self) -> dict:
+        """The state once the level is back after a death: while it restarts the clock is frozen and
+        the floors are gone (the gap that is not there); an action during that window is spent."""
+        st = await self._eval(STATE_JS)
+        if isinstance(st, dict) and self._restarting(st):
+            await self._up(*list(self._held))
+            for _ in range(20):
+                await asyncio.sleep(0.25)
+                st = await self._eval(STATE_JS)
+                if isinstance(st, dict) and st.get("ready") and st.get("on_ground") and not self._restarting(st):
+                    break
+        return st if isinstance(st, dict) else {"ready": False}
+
+    def _restarting(self, st: dict) -> bool:
+        lives = st.get("lives")
+        if self._lives is not None and lives is not None and lives < self._lives:
+            self._restarting_until = time.time() + 4.0
+        if lives is not None:
+            self._lives = lives
+        if st.get("dead") or st.get("dying"):
+            self._restarting_until = max(self._restarting_until, time.time() + 3.0)
+        return time.time() < self._restarting_until
+
+    def act(self, name: str, hold: str) -> dict:
+        seconds = HOLDS.get(hold, HOLDS["medium"])
+
+        async def go():
+            await self._start()
+            await self._macro(name, seconds)
+            await asyncio.sleep(0.05)
+            st = await self._settled()
+            await self._frame()
+            return st
+        st = self._run(go())
+        self.steps += 1
+        d = self._describe(st)
+        d["text"] = f"{name} held {seconds:.2f} s. " + d["text"]
+        return d
+
+    def wait(self) -> dict:
+        async def go():
+            await self._start()
+            await self._macro("wait", 0.25)
+            st = await self._settled()
+            await self._frame()
+            return st
+        d = self._describe(self._run(go()))
+        d["text"] = "Waited 0.25 s. " + d["text"]
+        return d
+
+    def _describe(self, st: dict) -> dict:
+        if not st.get("ready"):
+            return {"ok": True, "text": "The game is loading.", "fields": {"ready": False}, "candidates": {}, "terminal": False}
+        restarting = self._restarting(st)
+        if restarting:
+            lives = st.get("lives")
+            return {"ok": True, "text": f"Mario has just died. Lives left: {lives}. The level restarts from the beginning in a moment; wait.",
+                    "fields": {"dead": True, "lives": lives, "restarting": True}, "candidates": {},
+                    "terminal": bool(lives is not None and lives <= 0)}
+        parts = []
+        if st.get("dead"):
+            parts.append("Mario has just died; the level restarts in a moment.")
+        else:
+            motion = ("moving right" if st["xvel"] > 0.3 else "moving left" if st["xvel"] < -0.3 else "standing still")
+            parts.append(f"Mario is {'on the ground' if st['on_ground'] else 'in the air'} at x {st['x']} tiles of a "
+                         f"{st['screen_tiles']} tile screen, {motion}.")
+        en = st.get("enemies") or []
+        if en:
+            e = en[0]
+            where = "at Mario's height" if abs(e["dy"]) < 1 else ("above" if e["dy"] > 0 else "below")
+            parts.append(f"Nearest enemy: {e['kind']} {e['dx']} tiles ahead, {where}." + (f" {len(en) - 1} more behind it." if len(en) > 1 else ""))
+        else:
+            parts.append("No enemy within 12 tiles ahead.")
+        gaps = st.get("gaps") or []
+        parts.append(f"Gap in the ground: edge {gaps[0]['dx']} tiles ahead, {gaps[0]['width']} tiles wide." if gaps
+                     else "No gap in the ground within 12 tiles.")
+        walls = st.get("walls") or []
+        parts.append(f"Wall ahead: {walls[0]['kind']} {walls[0]['dx']} tiles ahead, {walls[0]['height']} tiles tall." if walls
+                     else "No pipe or wall within 8 tiles.")
+        # what one step reaches, and what is inside it: the fact the rule needs, stated rather
+        # than left for the model to work out from a speed and a distance (it jumped one step late)
+        # measured on the live game: at a run the distance to a walking enemy closes about 5.5
+        # tiles a step (11.5 -> 6 -> 1.3), a standing wall about 4; the hold, the model's answer
+        # and the enemy's own walk all fit in one step
+        reach = round(max(1.0, abs(st.get("xvel") or 0) * 60 * 0.6 / (8 * 4)), 1)
+        closing = round(reach + 1.5, 1)
+        within = [f"the {en[0]['kind']} {en[0]['dx']} tiles ahead"] if en and en[0]["dx"] <= closing + 0.5 else []
+        within += [f"the gap {gaps[0]['dx']} tiles ahead"] if gaps and gaps[0]["dx"] <= reach + 0.5 else []
+        within += [f"the {walls[0]['kind']} {walls[0]['dx']} tiles ahead"] if walls and walls[0]["dx"] <= reach + 0.5 else []
+        parts.append(f"One step reaches about {reach} tiles, and a walking enemy closes about {closing}. "
+                     + (f"Within one step: {'; '.join(within)}." if within else "Nothing is within one step."))
+        parts.append(f"Lives {st.get('lives')}, time {st.get('time')}, score {st.get('score')}.")
+        terminal = bool(st.get("ending")) or (bool(st.get("dead")) and (st.get("lives") or 0) <= 0)
+        fields = {k: st.get(k) for k in ("x", "y", "on_ground", "dead", "xvel", "lives", "time", "score", "world")}
+        fields["enemies"] = en
+        fields["gaps"] = gaps
+        fields["walls"] = walls
+        fields["step_reach_tiles"] = reach
+        fields["within_one_step"] = within
+        return {"ok": True, "text": " ".join(parts), "fields": fields, "candidates": {}, "terminal": terminal}
+
+
+def build(game: Game):
+    import warnings
+    warnings.filterwarnings("ignore", message=".*lifespan.*")
+    from mcp.server.mcpserver import MCPServer
+    from mcp.types import ToolAnnotations
+
+    m = MCPServer("mario", instructions=INSTRUCTIONS, log_level="WARNING")
+    Hold = Annotated[str, Field(description="How long to hold the keys.",
+                                json_schema_extra={"oneOf": [{"const": "short", "description": "about 0.15 s, a small step or hop"},
+                                                             {"const": "medium", "description": "about 0.35 s, a normal jump or stride"},
+                                                             {"const": "long", "description": "about 0.6 s, the highest jump or a long run"}]})]
+
+    @m.tool(annotations=ToolAnnotations(readOnlyHint=True), description="Where Mario is and what is ahead, right now.")
+    def observe() -> dict:
+        return game.observe()
+
+    @m.tool(description="Reload the game for a new run.")
+    def reset(goal: str = "") -> dict:
+        return game.reset(goal)
+
+    # A key held for a moment changes nothing outside the game, so these are read-risk: gated as
+    # writes (0.7) the model was refused three times mid-air at 0.40 to 0.59 and the run stopped.
+    keys = {"risk": "read"}
+
+    @m.tool(description="Run to the right, and keep running until told otherwise.", meta=keys)
+    def run_right(hold: Hold) -> dict:
+        return game.act("run_right", hold)
+
+    @m.tool(description="Jump while running right, over an enemy, a gap or a wall ahead; the run continues after the jump.", meta=keys)
+    def jump_right(hold: Hold) -> dict:
+        return game.act("jump_right", hold)
+
+    @m.tool(description="Jump straight up, without moving.", meta=keys)
+    def jump(hold: Hold) -> dict:
+        return game.act("jump", hold)
+
+    @m.tool(description="Walk to the left, to back away from something.", meta=keys)
+    def walk_left(hold: Hold) -> dict:
+        return game.act("walk_left", hold)
+
+    @m.tool(annotations=ToolAnnotations(readOnlyHint=True), description="Let go of every key, stand still for a quarter second and look again.")
+    def wait() -> dict:
+        return game.wait()
+
+    return m
+
+
+def main() -> int:
+    game = Game()
+    try:
+        build(game).run("stdio")
+    finally:
+        try:
+            if game._session is not None:
+                game._run(game._session.kill(), 15)
+        except Exception:  # noqa: BLE001
+            pass
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

From ae389cf0790eef4acb81eb94c5237ba64f32bec0 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sat, 19 Sep 2026 21:26:17 -0700
Subject: [PATCH 02/26] mario: the panes fill the viewport and the panel
 scrolls; the list keeps its last 150 items

Verified on the public console at 1440 and 390 while a run streamed: the
frame stays in view, the panel scrolls inside, Stop cancels the run.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/app/app.css | 16 ++++++++++------
 kits/mario/app/app.js  | 14 ++++++++++----
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/kits/mario/app/app.css b/kits/mario/app/app.css
index 63a1617..eb13ac3 100644
--- a/kits/mario/app/app.css
+++ b/kits/mario/app/app.css
@@ -1,18 +1,20 @@
 :root { color-scheme: light dark; font: 14px/1.45 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; --accent: #E4572E; }
 * { box-sizing: border-box; }
-body { margin: 0; min-height: 100vh; display: flex; flex-direction: column; }
+html, body { height: 100%; }
+body { margin: 0; height: 100vh; display: flex; flex-direction: column; overflow: hidden; }
 .top { display: flex; align-items: center; justify-content: space-between; padding: 10px 16px; border-bottom: 1px solid #8883; }
 .brand { display: flex; align-items: center; gap: 10px; }
 .brand img { border-radius: 6px; }
 h1 { font-size: 16px; margin: 0; }
-.panes { display: grid; grid-template-columns: minmax(0, 1.6fr) minmax(320px, 1fr); gap: 0; flex: 1; min-height: 0; }
-.stage { padding: 16px; border-right: 1px solid #8883; display: flex; flex-direction: column; gap: 12px; min-width: 0; }
+.panes { display: grid; grid-template-columns: minmax(0, 1.6fr) minmax(320px, 1fr); gap: 0; flex: 1; min-height: 0; overflow: hidden; }
+.stage { padding: 16px; border-right: 1px solid #8883; display: flex; flex-direction: column; gap: 12px; min-width: 0; min-height: 0; overflow: auto; }
 .frame-box { position: relative; width: 100%; aspect-ratio: 16 / 10; background: #101828; border-radius: 10px; overflow: hidden; display: flex; align-items: center; justify-content: center; }
 .frame-box img { width: 100%; height: 100%; object-fit: contain; display: block; image-rendering: pixelated; }
 .frame-note { color: #cbd5e1; padding: 24px; text-align: center; max-width: 36ch; }
 .credits { color: #888; font-size: 12px; margin: 0; }
 .credits a { color: inherit; }
-.panel { padding: 16px; display: flex; flex-direction: column; gap: 8px; min-width: 0; overflow: auto; }
+.panel { padding: 16px; display: flex; flex-direction: column; gap: 8px; min-width: 0; min-height: 0; overflow: auto; }
+.panel ol#steps { overflow: visible; }
 label { font-weight: 600; margin-top: 4px; }
 textarea { width: 100%; font: inherit; padding: 8px; border: 1px solid #8884; border-radius: 8px; background: transparent; color: inherit; resize: vertical; }
 button { font: inherit; padding: 7px 14px; border-radius: 8px; border: 1px solid #8886; background: var(--accent); color: #fff; cursor: pointer; }
@@ -33,6 +35,8 @@ ol#steps li { margin: 5px 0; }
 .reason { color: #8a6d00; font-style: italic; }
 .final { font-weight: 600; }
 @media (max-width: 860px) {
-  .panes { grid-template-columns: 1fr; }
-  .stage { border-right: 0; border-bottom: 1px solid #8883; }
+  .panes { grid-template-columns: 1fr; grid-template-rows: auto minmax(0, 1fr); }
+  .stage { border-right: 0; border-bottom: 1px solid #8883; overflow: visible; padding: 10px 12px; }
+  .stage .credits { display: none; }
+  .frame-box { aspect-ratio: 16 / 9; }
 }
diff --git a/kits/mario/app/app.js b/kits/mario/app/app.js
index 2313e8f..aebae4a 100644
--- a/kits/mario/app/app.js
+++ b/kits/mario/app/app.js
@@ -8,9 +8,15 @@ const esc = (s) => String(s ?? '').replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<'
 
 function setStatus(text, cls) { const s = $('status'); s.textContent = text; s.className = 'pill' + (cls ? ' ' + cls : ''); }
 function addStep(html, cls) {
-  const li = document.createElement('li'); li.className = cls || ''; li.innerHTML = html; $('steps').appendChild(li);
-  li.scrollIntoView({ block: 'nearest' });
+  const list = $('steps');
+  const li = document.createElement('li'); li.className = cls || ''; li.innerHTML = html; list.appendChild(li);
+  while (list.children.length > 150) list.removeChild(list.firstChild);   // the last 150 items, the run goes on
+  state.itemsTotal = (state.itemsTotal || 0) + 1;
+  list.start = state.itemsTotal - list.children.length + 1;      // numbering continues past the trim
+  const panel = list.closest('.panel');
+  if (panel) panel.scrollTop = panel.scrollHeight;
 }
+let calls = 0;
 
 async function harness() {
   if (state.harness) return state.harness;
@@ -46,8 +52,8 @@ async function start(previous) {
   $('steps').innerHTML = ''; $('final').hidden = true; $('traceMeta').textContent = ''; $('taskNote').textContent = '';
   $('startBtn').disabled = true; $('cancelBtn').hidden = false; $('continueBtn').hidden = true;
   setStatus('running', 'running');
-  state.controller = new AbortController(); state.startedAt = performance.now();
-  let calls = 0;
+  state.controller = new AbortController(); state.startedAt = performance.now(); state.itemsTotal = 0;
+  calls = 0;
   try {
     const r = await fetch(`${API}/responses`, { method: 'POST', headers: { 'content-type': 'application/json', accept: 'text/event-stream' },
       body: JSON.stringify(body), signal: state.controller.signal, cache: 'no-store' });

From b4fa314a3fca97086c89f028cbc0e5a6676bbb0c Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sat, 19 Sep 2026 22:07:40 -0700
Subject: [PATCH 03/26] mario: the page is the kits' shape, the frame streams,
 and a tall pipe is jumped

The page is rebuilt as the other four kits are built: a Vite app with the shared app bar (with
the way back to HarnessRouter), the stage on the left and the run's real conversation on the
right in the shared chat column, every decision with the game's reply, reopenable from its link.
Play starts a run with the default goal; the stage shows the run's counted figures and Stop.
Before the first frame there is an empty state, not a broken image.

The frame is Chrome's own screencast now, every third frame the game draws written to frame.jpg
(about twenty a second, 7 KB each), read by the page with a few requests in flight and shown as
each decodes, instead of one capture per step that played like slides.

The environment measures the game instead of guessing: the wall detector keeps the pipe Mario is
pressed against (a dx >= 0 filter dropped it, and a run stood at a 4-tile pipe for forty steps
saying no wall was within 8 tiles); wall heights are taken from the ground, not from the feet
mid-jump; the state says which hold clears the wall (short 3.1 tiles, medium 3.9, long 4.1,
measured); and jump_right times the take-off, since a 4-tile pipe is cleared only from 1.5 to 3
tiles back and an enemy jumped from 2 tiles at a run is hit on take-off. On the model's own runs
all four pipes of the level are cleared, three times in a row within 120 steps.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/README.md                         |   60 +-
 kits/mario/app/app.css                       |   42 -
 kits/mario/app/app.js                        |  118 --
 kits/mario/app/icon.svg                      |    7 -
 kits/mario/app/index.html                    |   52 +-
 kits/mario/app/package-lock.json             | 1856 ++++++++++++++++++
 kits/mario/app/package.json                  |   20 +
 kits/mario/app/src/App.jsx                   |   26 +
 kits/mario/app/src/components/ChatColumn.jsx |   73 +
 kits/mario/app/src/components/MkMark.jsx     |   12 +
 kits/mario/app/src/components/Stage.jsx      |  102 +
 kits/mario/app/src/components/Topbar.jsx     |   86 +
 kits/mario/app/src/lib/auth.js               |   29 +
 kits/mario/app/src/lib/frames.js             |   78 +
 kits/mario/app/src/lib/game.js               |   54 +
 kits/mario/app/src/lib/kit.js                |   17 +
 kits/mario/app/src/main.jsx                  |   12 +
 kits/mario/app/src/pages/GamePage.jsx        |  131 ++
 kits/mario/app/src/styles/app.css            |  104 +
 kits/mario/app/src/styles/tokens.css         |  107 +
 kits/mario/app/vite.config.js                |   11 +
 kits/mario/kit.json                          |   19 +-
 kits/mario/plugin/server/mario_env.py        |  178 +-
 23 files changed, 2935 insertions(+), 259 deletions(-)
 delete mode 100644 kits/mario/app/app.css
 delete mode 100644 kits/mario/app/app.js
 delete mode 100644 kits/mario/app/icon.svg
 create mode 100644 kits/mario/app/package-lock.json
 create mode 100644 kits/mario/app/package.json
 create mode 100644 kits/mario/app/src/App.jsx
 create mode 100644 kits/mario/app/src/components/ChatColumn.jsx
 create mode 100644 kits/mario/app/src/components/MkMark.jsx
 create mode 100644 kits/mario/app/src/components/Stage.jsx
 create mode 100644 kits/mario/app/src/components/Topbar.jsx
 create mode 100644 kits/mario/app/src/lib/auth.js
 create mode 100644 kits/mario/app/src/lib/frames.js
 create mode 100644 kits/mario/app/src/lib/game.js
 create mode 100644 kits/mario/app/src/lib/kit.js
 create mode 100644 kits/mario/app/src/main.jsx
 create mode 100644 kits/mario/app/src/pages/GamePage.jsx
 create mode 100644 kits/mario/app/src/styles/app.css
 create mode 100644 kits/mario/app/src/styles/tokens.css
 create mode 100644 kits/mario/app/vite.config.js

diff --git a/kits/mario/README.md b/kits/mario/README.md
index cbceb11..bc114be 100644
--- a/kits/mario/README.md
+++ b/kits/mario/README.md
@@ -7,20 +7,49 @@ it plays in.
 
 - **The harness** is a fork of the `systemone` base (the open-source
   [System One Harness](https://github.com/HarnessRouter/SystemOneHarness)) with this kit's
-  instructions and one plugin.
+  instructions and one plugin. The base is general and knows nothing about this game; everything
+  about the game lives in the plugin, which is what a fork of a base is for.
 - **The plugin** (`plugin/`) ships an MCP server, `bin/mario-env`, that is the environment: it
   opens the game in a headless Chromium inside the deployment, reads the game's own state each step
   and says it as short literal sentences (where Mario is, whether he is on the ground, the nearest
-  enemy, gap and wall with distances in tiles), and acts by holding the keys the game listens to
-  (`run_right`, `jump_right`, `jump`, `walk_left`, `wait`, each with a hold length). The model never
-  sees a pixel and never writes text; it chooses.
-- **The page** (`app/`) shows `frame.jpg`, which the environment writes into the session's
-  workspace on every step, so the left pane is the model's own game, not a copy. The right pane
-  starts a run, streams every action with the game's reply and the step's latency, and can stop or
-  continue it.
+  enemy, gap and wall with distances in tiles, and which hold clears the wall), and acts by holding
+  the keys the game listens to (`run_right`, `jump_right`, `jump`, `walk_left`, `wait`, each with a
+  hold length). The model never sees a pixel and never writes text; it chooses.
+- **The page** (`app/`) is the same shape as the other kits: the stage on the left streams the
+  browser the model is playing in, and the conversation on the right is the run itself, every
+  decision with the game's reply, in the shared chat column the other kits mount. Play starts a
+  run with the default goal; the composer takes any other. The app bar has the way back to
+  HarnessRouter.
 
-The base is general and knows nothing about this game; everything about the game lives in this
-kit's plugin, which is what a fork of a base is for.
+### The frame
+
+The environment turns on the browser's own screencast and writes every third frame the game
+draws to `frame.jpg` in the session's workspace, about twenty a second at 7 KB each. The page reads
+that file through the session's live workspace, a few requests in flight at a time, shows a frame
+once it has decoded and drops any that arrives after a newer one. The rate the page shows is the
+rate of frames it actually displayed.
+
+### What is measured, not tuned
+
+The state is literal and the numbers in it come from the game. Two things were measured on the live
+game and are written into the environment rather than left to the model:
+
+- **Jump heights.** Feet above the ground at the apex: a short hold reaches 3.1 tiles, a medium 3.9,
+  a long 4.1, standing or at a run. So the state says which hold clears the wall ahead: short for
+  2 tiles, medium for 3, long for 4.
+- **When to leave the ground.** A decision lands every half second and a jump is a one-tile affair.
+  A wall 4 tiles tall is cleared by a long jump from 1.5 to 3 tiles back and from nowhere else:
+  from against it the apex is level with the top, and at a run from 4 tiles back the jump peaks
+  early and hits the side. A running jump covers about 9 tiles, so an enemy jumped from 4 tiles is
+  landed well past, and one jumped from 2 at a run is hit on take-off. The `jump_right` macro
+  therefore keeps running until the nearest thing ahead is at its distance, steps back first when
+  pressed against a tall wall, and waits for the landing when asked to jump mid-air. The model
+  decides to jump; the timing is the environment's, the way holding the keys is.
+
+On the model's own runs after these changes (Jev 1.13 through OpenRouter, 120 steps), all four
+pipes of the first level are cleared, three times in a row across restarts; before them a run
+stood against the first tall pipe for forty steps because the detector had dropped a pipe Mario
+overlapped by a tenth of a tile.
 
 ## Credits
 
@@ -34,4 +63,13 @@ kit's plugin, which is what a fork of a base is for.
 ## Running it
 
 Launch the kit from Starter Kits with an OpenRouter key connected. The first launch on a fresh
-install adds a Chromium beside the System One base (about a minute). Then press Start.
+install adds a Chromium beside the System One base (about a minute). Then press Play.
+
+## Developing the page
+
+```
+cd kits/mario/app
+npm install
+npm run dev        # against a console at the same origin, or set a proxy for /api and /kits
+npm run build      # what the image serves at /kits/mario
+```
diff --git a/kits/mario/app/app.css b/kits/mario/app/app.css
deleted file mode 100644
index eb13ac3..0000000
--- a/kits/mario/app/app.css
+++ /dev/null
@@ -1,42 +0,0 @@
-:root { color-scheme: light dark; font: 14px/1.45 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; --accent: #E4572E; }
-* { box-sizing: border-box; }
-html, body { height: 100%; }
-body { margin: 0; height: 100vh; display: flex; flex-direction: column; overflow: hidden; }
-.top { display: flex; align-items: center; justify-content: space-between; padding: 10px 16px; border-bottom: 1px solid #8883; }
-.brand { display: flex; align-items: center; gap: 10px; }
-.brand img { border-radius: 6px; }
-h1 { font-size: 16px; margin: 0; }
-.panes { display: grid; grid-template-columns: minmax(0, 1.6fr) minmax(320px, 1fr); gap: 0; flex: 1; min-height: 0; overflow: hidden; }
-.stage { padding: 16px; border-right: 1px solid #8883; display: flex; flex-direction: column; gap: 12px; min-width: 0; min-height: 0; overflow: auto; }
-.frame-box { position: relative; width: 100%; aspect-ratio: 16 / 10; background: #101828; border-radius: 10px; overflow: hidden; display: flex; align-items: center; justify-content: center; }
-.frame-box img { width: 100%; height: 100%; object-fit: contain; display: block; image-rendering: pixelated; }
-.frame-note { color: #cbd5e1; padding: 24px; text-align: center; max-width: 36ch; }
-.credits { color: #888; font-size: 12px; margin: 0; }
-.credits a { color: inherit; }
-.panel { padding: 16px; display: flex; flex-direction: column; gap: 8px; min-width: 0; min-height: 0; overflow: auto; }
-.panel ol#steps { overflow: visible; }
-label { font-weight: 600; margin-top: 4px; }
-textarea { width: 100%; font: inherit; padding: 8px; border: 1px solid #8884; border-radius: 8px; background: transparent; color: inherit; resize: vertical; }
-button { font: inherit; padding: 7px 14px; border-radius: 8px; border: 1px solid #8886; background: var(--accent); color: #fff; cursor: pointer; }
-button[disabled] { opacity: .5; cursor: default; }
-button.stop { background: #b91c1c; }
-button.quiet { background: transparent; color: inherit; }
-.row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
-.between { justify-content: space-between; }
-.note { color: #888; margin: 0; }
-.pill { font-size: 11px; padding: 2px 8px; border-radius: 999px; border: 1px solid #8886; }
-.pill.ok { border-color: #16a34a; color: #16a34a; }
-.pill.running { border-color: var(--accent); color: var(--accent); }
-.pill.bad { border-color: #b91c1c; color: #b91c1c; }
-ol#steps { padding-left: 20px; margin: 4px 0; }
-ol#steps li { margin: 5px 0; }
-.action { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; }
-.result { color: #777; }
-.reason { color: #8a6d00; font-style: italic; }
-.final { font-weight: 600; }
-@media (max-width: 860px) {
-  .panes { grid-template-columns: 1fr; grid-template-rows: auto minmax(0, 1fr); }
-  .stage { border-right: 0; border-bottom: 1px solid #8883; overflow: visible; padding: 10px 12px; }
-  .stage .credits { display: none; }
-  .frame-box { aspect-ratio: 16 / 9; }
-}
diff --git a/kits/mario/app/app.js b/kits/mario/app/app.js
deleted file mode 100644
index aebae4a..0000000
--- a/kits/mario/app/app.js
+++ /dev/null
@@ -1,118 +0,0 @@
-// The kit's page is a plain Unified Harness Protocol client, same-origin with the console's API
-// proxy: start a run on this kit's harness, stream its items, show the frame the environment
-// writes into the session's workspace. Every number shown comes from the server's own events.
-const $ = (id) => document.getElementById(id);
-const API = '/api/harness/v1';
-const state = { harness: null, responseId: null, sessionId: null, controller: null, startedAt: 0, frameTimer: null };
-const esc = (s) => String(s ?? '').replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c]));
-
-function setStatus(text, cls) { const s = $('status'); s.textContent = text; s.className = 'pill' + (cls ? ' ' + cls : ''); }
-function addStep(html, cls) {
-  const list = $('steps');
-  const li = document.createElement('li'); li.className = cls || ''; li.innerHTML = html; list.appendChild(li);
-  while (list.children.length > 150) list.removeChild(list.firstChild);   // the last 150 items, the run goes on
-  state.itemsTotal = (state.itemsTotal || 0) + 1;
-  list.start = state.itemsTotal - list.children.length + 1;      // numbering continues past the trim
-  const panel = list.closest('.panel');
-  if (panel) panel.scrollTop = panel.scrollHeight;
-}
-let calls = 0;
-
-async function harness() {
-  if (state.harness) return state.harness;
-  const r = await fetch(`${API}/harnesses`, { cache: 'no-store' });
-  if (!r.ok) throw new Error(`could not list harnesses (${r.status})`);
-  const { harnesses = [] } = await r.json();
-  state.harness = harnesses.find((h) => h.kit === 'mario') || null;
-  if (!state.harness) throw new Error('Super Mario has not been launched yet. Open Starter Kits and launch it.');
-  $('harnessName').textContent = state.harness.name || 'Super Mario';
-  $('harnessModel').textContent = state.harness.defaultModel || state.harness.default_model || '';
-  return state.harness;
-}
-
-function pollFrame() {
-  if (!state.sessionId) return;
-  const img = $('frame');
-  const next = () => { state.frameTimer = setTimeout(pollFrame, 180); };
-  const url = `${API}/sessions/${encodeURIComponent(state.sessionId)}/files/frame.jpg?t=${Date.now()}`;
-  const probe = new Image();
-  probe.onload = () => { img.src = probe.src; img.hidden = false; $('frameNote').hidden = true; next(); };
-  probe.onerror = next;
-  probe.src = url;
-}
-function stopFrames() { if (state.frameTimer) clearTimeout(state.frameTimer); state.frameTimer = null; }
-
-async function start(previous) {
-  const goal = $('goal').value.trim();
-  if (!goal) { $('taskNote').textContent = 'Give the run a goal.'; return; }
-  let h;
-  try { h = await harness(); } catch (e) { $('taskNote').textContent = e.message; return; }
-  const body = { input: goal, stream: true, metadata: { harness_id: h.id } };
-  if (previous) body.previous_response_id = previous;
-  $('steps').innerHTML = ''; $('final').hidden = true; $('traceMeta').textContent = ''; $('taskNote').textContent = '';
-  $('startBtn').disabled = true; $('cancelBtn').hidden = false; $('continueBtn').hidden = true;
-  setStatus('running', 'running');
-  state.controller = new AbortController(); state.startedAt = performance.now(); state.itemsTotal = 0;
-  calls = 0;
-  try {
-    const r = await fetch(`${API}/responses`, { method: 'POST', headers: { 'content-type': 'application/json', accept: 'text/event-stream' },
-      body: JSON.stringify(body), signal: state.controller.signal, cache: 'no-store' });
-    if (!r.ok) throw new Error(`${r.status} ${(await r.text()).slice(0, 200)}`);
-    const reader = r.body.getReader(); const dec = new TextDecoder(); let buf = '';
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buf += dec.decode(value, { stream: true });
-      let nl;
-      while ((nl = buf.indexOf('\n\n')) >= 0) {
-        const chunk = buf.slice(0, nl); buf = buf.slice(nl + 2);
-        for (const line of chunk.split('\n')) {
-          if (!line.startsWith('data: ')) continue;
-          let ev; try { ev = JSON.parse(line.slice(6)); } catch { continue; }
-          handle(ev);
-        }
-      }
-    }
-  } catch (e) {
-    if (e.name !== 'AbortError') { setStatus('failed', 'bad'); $('taskNote').textContent = e.message; }
-  } finally {
-    $('startBtn').disabled = false; $('cancelBtn').hidden = true;
-    if (state.responseId) $('continueBtn').hidden = false;
-    setTimeout(stopFrames, 1500);
-  }
-
-  function handle(ev) {
-    const t = ev.type;
-    if (t === 'response.created') {
-      state.responseId = ev.response.id;
-      const sid = ev.response.metadata?.session_id || null;
-      if (sid && sid !== state.sessionId) { state.sessionId = sid; stopFrames(); pollFrame(); }
-      $('traceTitle').textContent = `Steps · ${state.responseId.slice(0, 12)}…`;
-      return;
-    }
-    if (t === 'response.output_item.done') {
-      const it = ev.item; const ms = Math.round(performance.now() - state.startedAt);
-      if (it.type === 'function_call') { calls += 1; addStep(`<span class="action">${esc(it.name)}(${esc(it.arguments)})</span> <span class="note">${ms} ms</span>`); }
-      else if (it.type === 'function_call_output') addStep(`<span class="result">${esc(it.output)}</span>`);
-      else if (it.type === 'reasoning') addStep(`<span class="reason">${esc((it.summary || [])[0]?.text || '')}</span>`);
-      else if (it.type === 'message') { $('final').textContent = (it.content || [])[0]?.text || ''; $('final').hidden = false; }
-      return;
-    }
-    if (t === 'response.completed' || t === 'response.incomplete' || t === 'response.failed') {
-      const r = ev.response; const u = r.usage; const secs = ((performance.now() - state.startedAt) / 1000).toFixed(1);
-      setStatus(r.status + (r.incomplete_details?.reason ? `: ${r.incomplete_details.reason}` : ''), r.status === 'completed' ? 'ok' : 'bad');
-      $('traceMeta').textContent = `${calls} action${calls === 1 ? '' : 's'} · ${secs} s` + (u ? ` · ${u.input_tokens} in / ${u.output_tokens} out` : '') + (r.model ? ` · ${r.model}` : '');
-      if (r.error) $('taskNote').textContent = r.error.message || JSON.stringify(r.error);
-    }
-  }
-}
-
-async function cancel() {
-  if (!state.responseId) return;
-  try { await fetch(`${API}/responses/${encodeURIComponent(state.responseId)}/cancel`, { method: 'POST' }); } catch {}
-}
-
-$('startBtn').addEventListener('click', () => start(null));
-$('continueBtn').addEventListener('click', () => start(state.responseId));
-$('cancelBtn').addEventListener('click', cancel);
-harness().catch((e) => { $('taskNote').textContent = e.message; });
diff --git a/kits/mario/app/icon.svg b/kits/mario/app/icon.svg
deleted file mode 100644
index 019c875..0000000
--- a/kits/mario/app/icon.svg
+++ /dev/null
@@ -1,7 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Super Mario kit">
-  <rect width="64" height="64" rx="14" fill="#E4572E"/>
-  <rect x="14" y="36" width="36" height="14" rx="3" fill="#7A2E12"/>
-  <rect x="24" y="16" width="16" height="20" rx="4" fill="#FFE8D6"/>
-  <rect x="20" y="12" width="24" height="8" rx="3" fill="#B71C1C"/>
-  <circle cx="29" cy="25" r="2" fill="#1F1F1F"/><circle cx="35" cy="25" r="2" fill="#1F1F1F"/>
-</svg>
diff --git a/kits/mario/app/index.html b/kits/mario/app/index.html
index 06687d9..3846618 100644
--- a/kits/mario/app/index.html
+++ b/kits/mario/app/index.html
@@ -1,45 +1,13 @@
 <!doctype html>
 <html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Super Mario</title>
-<link rel="stylesheet" href="/kits/mario/app.css">
-</head>
-<body>
-<header class="top">
-  <div class="brand"><img src="/kits/mario/icon.svg" alt="" width="28" height="28"><h1>Super Mario</h1></div>
-  <span id="status" class="pill">ready</span>
-</header>
-<main class="panes">
-  <section class="stage">
-    <div class="frame-box">
-      <img id="frame" alt="The frame of the browser the model is playing in" hidden>
-      <div id="frameNote" class="frame-note">Press Start. The frame of the browser the model plays in appears here, written by the environment on every step.</div>
-    </div>
-    <p class="credits">The game is <a href="https://supermarioplay.com/game/mario.html?v=1.0.1" target="_blank" rel="noopener">Full Screen Mario at supermarioplay.com</a>; Mario belongs to Nintendo and none of the game's files ship here. The browser is driven with <a href="https://github.com/browser-use/browser-use" target="_blank" rel="noopener">Browser Use</a> (MIT). The model is <a href="https://typesafe.ai" target="_blank" rel="noopener">Jev</a> by TypeSafe, a System One model, through OpenRouter. The harness is the open-source <a href="https://github.com/HarnessRouter/SystemOneHarness" target="_blank" rel="noopener">System One Harness</a>.</p>
-  </section>
-  <section class="panel">
-    <div class="row between">
-      <strong id="harnessName">Super Mario</strong>
-      <span id="harnessModel" class="note"></span>
-    </div>
-    <label for="goal">Goal</label>
-    <textarea id="goal" rows="2">Play the level: keep running right, jump over enemies, gaps and pipes, and get as far as you can.</textarea>
-    <div class="row">
-      <button id="startBtn">Start</button>
-      <button id="cancelBtn" class="stop" hidden>Stop</button>
-      <button id="continueBtn" class="quiet" hidden>Continue</button>
-    </div>
-    <p id="taskNote" class="note"></p>
-    <div class="row between">
-      <strong id="traceTitle">Steps</strong>
-      <span id="traceMeta" class="note"></span>
-    </div>
-    <ol id="steps"></ol>
-    <p id="final" class="final" hidden></p>
-  </section>
-</main>
-<script src="/kits/mario/app.js"></script>
-</body>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Super Mario</title>
+    <link rel="icon" href="/kits/mario/icon.svg" type="image/svg+xml" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
 </html>
diff --git a/kits/mario/app/package-lock.json b/kits/mario/app/package-lock.json
new file mode 100644
index 0000000..867255c
--- /dev/null
+++ b/kits/mario/app/package-lock.json
@@ -0,0 +1,1856 @@
+{
+  "name": "harnessrouter-kit-mario",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "harnessrouter-kit-mario",
+      "license": "SEE LICENSE IN ../../LICENSE.md",
+      "dependencies": {
+        "lucide-react": "^0.469.0",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        "reifyui": "^0.11.1"
+      },
+      "devDependencies": {
+        "@vitejs/plugin-react": "^4.3.4",
+        "vite": "^6.0.7"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",
+      "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helpers": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz",
+      "integrity": "sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.8",
+        "@babel/types": "^7.29.8",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",
+      "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
+      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.9",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.9.tgz",
+      "integrity": "sha512-CjXrNHTnvqBVqHgdBysY3vk2T8tpJHb5/RMeHJBTyVa9xgugCB0CJTx/3oO8RV2QRQP391RWpB7D6hLjm8V9uA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.8"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz",
+      "integrity": "sha512-TL0hMc9xzy86VD31nUiwzd5otRAcyEPcsegCxolO0PvcXuH1v0kECe/UIznYFihpkvU5wg/jk4v0TTEFfm53fw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz",
+      "integrity": "sha512-06IyK09H3wi4cGbhDBwp5gUGo0IKtnYa8tyTiephirPCK6fbobVGiXMMI5zLQ4aKEYP3wZ3ArU44o+8KMrSG/Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz",
+      "integrity": "sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.8",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.8",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.8",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz",
+      "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz",
+      "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@napi-rs/lzma-linux-x64-gnu": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",
+      "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^22.20 || ^24.12 || >=25"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.4.tgz",
+      "integrity": "sha512-I+BSHzTAhKN2n7ZwGZsegGcZjDpLqFOMAtJz/u6uFGe0pUFbq56dEHjqJV/ZUdRJtNXNxA+hREUatZBvMR3Oiw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.4.tgz",
+      "integrity": "sha512-pu3BdjS2LtEzRu2elmGzS3fIeWSZy4BMDIaLNwjorO76+k2d0LMluijhsDx3KQyQBQ/lLUZCQA9/s6csvUfuhw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.4.tgz",
+      "integrity": "sha512-xfSrj9MHnWK9GaSqT9U0ImHtH/N8WZlHLx4cZHiuLcqs640hvZ3hLPd5UR2AZS57FaE8HrRUSpltbZdWRxHiDA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.4.tgz",
+      "integrity": "sha512-bqU99PLJb/dqb3S0GIMdeuyAEETSUgZBoqXYd3Sd+WCsV+MmPhnN6JrotWyir31+QgH7EvvE5/mwGJlEoci8Fw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.4.tgz",
+      "integrity": "sha512-JinsFZ5G40oXQb+sUuiA5x689vhr6dDYK0H0NL+rwKdL6CqnmYN8PE4ZwfRSoIjrCxqTQG/SLfTtSvHeGxoVlw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.4.tgz",
+      "integrity": "sha512-GAdA4UxpiNm27cLHr2GqXBpAD0x9FqwYBY7/YSP0Ss0/PNi4k8gbviqpIpYbVSRBaS2ZcegXEzgTQMbRNCwxCw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.4.tgz",
+      "integrity": "sha512-qDd6NoA1znaLjp4jR5U/KWCdLAKDJNB8W9ChbbDaKbo0xA+Atln5HK6LFCZ4oJQpemtRZA288DCirFRjrspptw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.4.tgz",
+      "integrity": "sha512-WtB5Tz5KTNINb8ZA+8sQ7bmjuS1JrRT7YverYIhUGdWWDlpzVWmIwuZE+jidkEXUn1l0zrEkaIMa8dHF3NGcsA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.4.tgz",
+      "integrity": "sha512-VcQ3L1tjnkKzWjryAVaFhHEWcqOfICX9uxVVoDzm2t0DpgKRHd2zOpVrJc0xsWeBZcBFyYROCIBdyR/fS174pg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.4.tgz",
+      "integrity": "sha512-6+ZQX6P5s0cMDN2Ypb8Lbm2+/sZYmZjdaYny992ujUU9UKi/4CWoJWsl1pNvjWJHNHGK51m+jKGLlh1ylb2ifQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.4.tgz",
+      "integrity": "sha512-D72ZnvkFkBXOfzMMQLcwfPLyGkKb7HZ9/mf97B7v6/P5Lbv4oFOtSY/uHbS8lH6uKUOxoKiuokdb50XZSzzbJw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.4.tgz",
+      "integrity": "sha512-piU6BxeqA3O9KSu3kRCIQQtNqFFaTu21SEV4FwaRZowpnj3bLaWPZHw+xFqCs0XlJ+aOH3PTRWGoglH+mKA/OA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.4.tgz",
+      "integrity": "sha512-/5PGpHwqt2EEEOUs1XwzubE/ucr0dWDQ+to3zqi4Ds7EWpwtQ79wXc4JBoxqj/OwpawTsKWzJxHfSuBOq3DrWA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.4.tgz",
+      "integrity": "sha512-cX3beZDLWt7G2oJF+nhChiT+qtaihs+S2xi7ziGmVB+2pwPng6D0Ed0HmElQOgv2UsUmSJJLGwpBao/3TDx3VA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.4.tgz",
+      "integrity": "sha512-1uz2mGWHyptR7DgHHrlbdRAjXK7v7elGZ9lMja910/RP+ZYbX6xAmCiU9UZSX4hqmgtHMv6lr5l3kq1HIOpcag==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.4.tgz",
+      "integrity": "sha512-nLS8topojxyz7SRpKR2IODRpQ0XPZ+xaOXvT3+hqK/Uy8Lo5HFgkkIBiIrCu5tL5YqzTvgovGw55PwpahTAGig==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.4.tgz",
+      "integrity": "sha512-gs7DRKotr3l3q+jGPQBjH0ng1FjlEDm5ueQrkw5JtQvtLyEIcLASqAEaor56BhkKRzk+IcQzrcanBdb/bBQn8g==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.4.tgz",
+      "integrity": "sha512-791ET7W17NnScOZM7h4dX5hYspxE28htPFsb1awY/NRR8+PRNkS53e475rDdxXXDrP+kwnCcNWg9CX5ztn/Aqw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.4.tgz",
+      "integrity": "sha512-iwZQRcmj7g88g3tzefIrQY7qvmuA/cfYwhrDtTBhsmukO4U2huVO5W+86XacUMRvdSFVAc6kZUZy21JaRwiB9w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.4.tgz",
+      "integrity": "sha512-dVHFp9gRWrdTpnqQuGfCwd7hOQDatK1VCP2iWhLY/cGrOQs/ucFzJ6A5SRqbXX12ZDI8EUuejSM5kwg+ja7Png==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.4.tgz",
+      "integrity": "sha512-t3NlauOW6gxZVVFcBEnO62Cb4wbyDFL416gTg1uFI/2tgqYQlf69FbSE115Ajre9I+c26Lk4mcmdFUsS/DGifQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.4.tgz",
+      "integrity": "sha512-xWuIaSye5FWZF8+UYtVEcHtRJDN5kN9Kfgxx3Kq8XIov9KSKbc1fiqQCm90SKrgQbUXZelbnUhnlUJmfSE7P9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.4.tgz",
+      "integrity": "sha512-9ALJJUOg/ZflMJepVo2PlgsGxSaxN7SQ4Z8GoZfVlarWr6r3rkHUNsd/zAio7p4YMtChSMXPionxej4Hkf6CXQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.4.tgz",
+      "integrity": "sha512-blj9z5qx/Pv4WU0W1NMFDB97e0JH5ed+aZGywW8WCvp/NhWX/4PFAq5uu6Q0AebNn+Vo6KzUYDT++JzTT5ojlQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.4.tgz",
+      "integrity": "sha512-Erx822VRBwLa124shbj+wNXe//BOgMEctDV0m1aqTQdNO1S69DgNUCFKC1RCeZfixs1J31l6igk1ziyXErbigQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.11.25",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.25.tgz",
+      "integrity": "sha512-gMmEShwwq7FJqMwvfRwvCl00v4kN+KOfJqXn+f4nrufak5gNHJOksd/60Dvjuz7sI8Y5WiSFBa8FEYr+zoyqCw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.29.0",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.0.tgz",
+      "integrity": "sha512-3GSvyjvDI4Dur1Meg2BekJquu5uF+9R9a1+5M1Mde192eZoXbeXjzgOsgqPS2V8D5wrrip0gR5Hf/GhWQ9ZzaA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.11.23",
+        "caniuse-lite": "^1.0.30001810",
+        "electron-to-chromium": "^1.5.427",
+        "node-releases": "^2.0.55",
+        "update-browserslist-db": "^1.3.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001810",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001810.tgz",
+      "integrity": "sha512-TITQPUkaz+aVk5GL6NhOdwk1aEaNTSDPsGFWrTuhKGtjTF70jL/Oht2W4c6rXUe5fu7Ie19VIahAXHIIiWWNeg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.433",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.433.tgz",
+      "integrity": "sha512-5lCAbyZBjtmUt/RAGHRqrL2q0oEFRThDAsZHHDn9XHa89Qw7gMYOeSicBTy+AHfvo0r6vwsZvqNJTQIQy1BLzA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/lucide-react": {
+      "version": "0.469.0",
+      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.469.0.tgz",
+      "integrity": "sha512-28vvUnnKQ/dBwiCQtwJw7QauYnE7yd2Cyp4tTTJpvglX4EMpbflcdBgrgToX2j71B3YvugK/NH3BGUk+E/p/Fw==",
+      "license": "ISC",
+      "peerDependencies": {
+        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.19",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz",
+      "integrity": "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.56",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.56.tgz",
+      "integrity": "sha512-x0InOIyzgdk+eyaWaRJFH5snEtiImgBgblZ2CyPrLmqqcuMQkEvcDPHbzqbD8eDsSeJbVOjn+crzyzHaM4D+/A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz",
+      "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.28",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz",
+      "integrity": "sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.18",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/reifyui": {
+      "version": "0.11.1",
+      "resolved": "https://registry.npmjs.org/reifyui/-/reifyui-0.11.1.tgz",
+      "integrity": "sha512-nRERhMi4bTgxol6O0HjwPFuhnECHNe02X8hm9nNmLGLv44DmF2iFYZPJco6QZbCbh+yYOxzWWiC6B9fpw7h3Mw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "echarts": "^5 || ^6",
+        "highlight.js": "^11",
+        "mermaid": "^10 || ^11",
+        "react": ">=18",
+        "react-dom": ">=18",
+        "react-file-icon": "^1"
+      },
+      "peerDependenciesMeta": {
+        "echarts": {
+          "optional": true
+        },
+        "highlight.js": {
+          "optional": true
+        },
+        "mermaid": {
+          "optional": true
+        },
+        "react-file-icon": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.63.4",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.63.4.tgz",
+      "integrity": "sha512-4U0liVayNIoLp3GFl1FcI8561WepLnZ1rqfraGh7S9B3Ur5F9S283y8Futii7RUU2C/97tOBmBy7nYvhoiOpbQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@napi-rs/lzma-linux-x64-gnu": "1.5.1",
+        "@rollup/rollup-android-arm-eabi": "4.63.4",
+        "@rollup/rollup-android-arm64": "4.63.4",
+        "@rollup/rollup-darwin-arm64": "4.63.4",
+        "@rollup/rollup-darwin-x64": "4.63.4",
+        "@rollup/rollup-freebsd-arm64": "4.63.4",
+        "@rollup/rollup-freebsd-x64": "4.63.4",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.63.4",
+        "@rollup/rollup-linux-arm-musleabihf": "4.63.4",
+        "@rollup/rollup-linux-arm64-gnu": "4.63.4",
+        "@rollup/rollup-linux-arm64-musl": "4.63.4",
+        "@rollup/rollup-linux-loong64-gnu": "4.63.4",
+        "@rollup/rollup-linux-loong64-musl": "4.63.4",
+        "@rollup/rollup-linux-ppc64-gnu": "4.63.4",
+        "@rollup/rollup-linux-ppc64-musl": "4.63.4",
+        "@rollup/rollup-linux-riscv64-gnu": "4.63.4",
+        "@rollup/rollup-linux-riscv64-musl": "4.63.4",
+        "@rollup/rollup-linux-s390x-gnu": "4.63.4",
+        "@rollup/rollup-linux-x64-gnu": "4.63.4",
+        "@rollup/rollup-linux-x64-musl": "4.63.4",
+        "@rollup/rollup-openbsd-x64": "4.63.4",
+        "@rollup/rollup-openharmony-arm64": "4.63.4",
+        "@rollup/rollup-win32-arm64-msvc": "4.63.4",
+        "@rollup/rollup-win32-ia32-msvc": "4.63.4",
+        "@rollup/rollup-win32-x64-gnu": "4.63.4",
+        "@rollup/rollup-win32-x64-msvc": "4.63.4",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz",
+      "integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "6.4.3",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.3.tgz",
+      "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}
diff --git a/kits/mario/app/package.json b/kits/mario/app/package.json
new file mode 100644
index 0000000..778bc29
--- /dev/null
+++ b/kits/mario/app/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "harnessrouter-kit-mario",
+  "private": true,
+  "license": "SEE LICENSE IN ../../LICENSE.md",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build"
+  },
+  "dependencies": {
+    "lucide-react": "^0.469.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "reifyui": "^0.11.1"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.4",
+    "vite": "^6.0.7"
+  }
+}
diff --git a/kits/mario/app/src/App.jsx b/kits/mario/app/src/App.jsx
new file mode 100644
index 0000000..aaa42e7
--- /dev/null
+++ b/kits/mario/app/src/App.jsx
@@ -0,0 +1,26 @@
+// Hash router.
+//   #/            a new run: nothing exists until the first message opens a session
+//   #/r/{id}      a run (a session on this kit's harness), with its conversation and its frame
+//
+// The console authenticates the person before this app is served, so there is no sign-in here
+// and no token to refresh. See lib/auth.js.
+import { useEffect, useState } from 'react';
+import { DialogHost } from 'reifyui';
+import { GamePage } from './pages/GamePage';
+import { PENDING } from './lib/game';
+
+function parseHash() {
+  const raw = window.location.hash.replace(/^#\/?/, '');
+  if (raw.startsWith('r/')) return { id: decodeURIComponent(raw.slice(2).split('?')[0]) };
+  return { id: PENDING };
+}
+
+export default function App() {
+  const [route, setRoute] = useState(parseHash);
+  useEffect(() => {
+    const onHash = () => setRoute(parseHash());
+    window.addEventListener('hashchange', onHash);
+    return () => window.removeEventListener('hashchange', onHash);
+  }, []);
+  return <DialogHost><GamePage key={route.id} id={route.id} /></DialogHost>;
+}
diff --git a/kits/mario/app/src/components/ChatColumn.jsx b/kits/mario/app/src/components/ChatColumn.jsx
new file mode 100644
index 0000000..29dca9b
--- /dev/null
+++ b/kits/mario/app/src/components/ChatColumn.jsx
@@ -0,0 +1,73 @@
+// The run's conversation: the goal the person gave, every decision the model made with the game's
+// reply, and the closing sentence. The panel is reifyui's ChatPanel, the same one the other kits
+// mount; what is left here is the two functions that reach the backend and the words on screen.
+import { useCallback } from 'react';
+import { Gamepad2 } from 'lucide-react';
+import { ChatPanel } from 'reifyui';
+import { streamTurn, turnsToMessages } from 'reifyui/harness';
+import { isPending, sessionTurns } from '../lib/game';
+
+const TOOL_LABELS = {
+  run_right: 'Run right',
+  jump_right: 'Jump right',
+  jump: 'Jump',
+  walk_left: 'Walk left',
+  wait: 'Wait',
+  observe: 'Look',
+  reset: 'Open the game',
+};
+
+export function ChatColumn({ runId, seed, onSeedConsumed, handlers, externalBusy, onSessionStarted,
+                             width, collapsed, onToggle }) {
+  const runTurn = useCallback(({ sessionId, text, handlers: panel }) => streamTurn({
+    sessionId: isPending(sessionId) ? '' : sessionId,
+    input: text,
+    // the page counts the run from the same events the panel renders
+    handlers: {
+      ...panel,
+      onCreated: (rid) => { handlers.onCreated?.(rid); panel.onCreated?.(rid); },
+      onToolCall: (name, args, callId) => { handlers.onToolCall?.(name, args, callId); panel.onToolCall?.(name, args, callId); },
+      onToolResult: (callId, output) => { handlers.onToolResult?.(callId, output); panel.onToolResult?.(callId, output); },
+      onDone: (status, response) => { handlers.onDone?.(status, response); panel.onDone?.(status, response); },
+      onError: (message) => { handlers.onError?.(message); panel.onError?.(message); },
+    },
+  }), [handlers]);
+
+  const loadHistory = useCallback((sessionId) => (
+    isPending(sessionId) ? Promise.resolve([]) : sessionTurns(sessionId).then(turnsToMessages)
+  ), []);
+
+  return (
+    <ChatPanel
+      sessionId={runId}
+      runTurn={runTurn}
+      loadHistory={loadHistory}
+      onSessionStarted={onSessionStarted}
+      seed={seed}
+      onSeedConsumed={onSeedConsumed}
+      externalBusy={externalBusy}
+      title="Run"
+      collapsed={collapsed}
+      onToggleCollapse={onToggle}
+      width={width}
+      placeholder="Tell Mario what to do…"
+      workingLabel="Playing…"
+      toolLabels={TOOL_LABELS}
+      busyState={(
+        <div className="uic-chat-empty">
+          <span className="uic-chat-pulse" aria-hidden="true" />
+          <div className="uic-chat-empty-t">Playing</div>
+          <div>Every decision arrives here as it is made, with the game's reply.</div>
+        </div>
+      )}
+      emptyState={(
+        <div className="uic-chat-empty">
+          <Gamepad2 size={26} />
+          <div className="uic-chat-empty-t">Your run</div>
+          <div>Press Play, or type a goal. Every decision the model makes shows here, with what the
+            game said back, and the run ends with one sentence on how it went.</div>
+        </div>
+      )}
+    />
+  );
+}
diff --git a/kits/mario/app/src/components/MkMark.jsx b/kits/mario/app/src/components/MkMark.jsx
new file mode 100644
index 0000000..e012a90
--- /dev/null
+++ b/kits/mario/app/src/components/MkMark.jsx
@@ -0,0 +1,12 @@
+// The kit's mark: the same drawing as kits/mario/icon.svg, which the console renders.
+export function MkMark({ size = 20 }) {
+  return (
+    <svg width={size} height={size} viewBox="0 0 64 64" aria-hidden="true">
+      <rect width="64" height="64" rx="14" fill="#E4572E" />
+      <rect x="14" y="36" width="36" height="14" rx="3" fill="#7A2E12" />
+      <rect x="24" y="16" width="16" height="20" rx="4" fill="#FFE8D6" />
+      <rect x="20" y="12" width="24" height="8" rx="3" fill="#B71C1C" />
+      <circle cx="29" cy="25" r="2" fill="#1F1F1F" /><circle cx="35" cy="25" r="2" fill="#1F1F1F" />
+    </svg>
+  );
+}
diff --git a/kits/mario/app/src/components/Stage.jsx b/kits/mario/app/src/components/Stage.jsx
new file mode 100644
index 0000000..340d32a
--- /dev/null
+++ b/kits/mario/app/src/components/Stage.jsx
@@ -0,0 +1,102 @@
+// The stage: the frame of the browser the model is playing in, with the run's figures over it.
+//
+// Every number here is counted from the run's own stream: actions from the tool calls, deaths
+// from the lives the environment states, the frame rate from frames this page actually showed.
+// Nothing is estimated.
+import { Eye, Keyboard, Play, Square, Zap } from 'lucide-react';
+import { CONSOLE_KITS } from '../lib/kit';
+import { statusLabel } from '../lib/game';
+
+function Empty({ harness, status, running, onPlay }) {
+  if (harness === null) {
+    return (
+      <div className="mk-empty">
+        <div className="mk-empty-t">Super Mario has not been launched yet</div>
+        <div>Launch it from Starter Kits and come back here.</div>
+        <a className="btn mk-play" href={CONSOLE_KITS}>Open Starter Kits</a>
+      </div>
+    );
+  }
+  if (running) {
+    return (
+      <div className="mk-empty">
+        <span className="mk-pulse" aria-hidden="true" />
+        <div className="mk-empty-t">Starting the browser</div>
+        <div>The game is loading in a browser inside this deployment. Its frame appears here as soon as it draws.</div>
+      </div>
+    );
+  }
+  if (status) {
+    return (
+      <div className="mk-empty">
+        <div className="mk-empty-t">{statusLabel(status)}</div>
+        <div>The frame of this run is no longer available. Start a new run to play again.</div>
+      </div>
+    );
+  }
+  return (
+    <div className="mk-empty">
+      <div className="mk-empty-t">Watch a System One model play</div>
+      <div>It reads the game's state a few times a second and holds one key at a time. The browser it plays in appears here.</div>
+      <button type="button" className="btn primary mk-play" onClick={onPlay} disabled={harness === undefined}>
+        <Play size={16} aria-hidden="true" />Play
+      </button>
+    </div>
+  );
+}
+
+function Stat({ label, value }) {
+  return <span className="mk-stat"><b>{value}</b><span>{label}</span></span>;
+}
+
+export function Stage({ frame, fps, harness, status, running, stats, onPlay, onStop }) {
+  const elapsed = stats.startedAt ? Math.round(((stats.endedAt || Date.now()) - stats.startedAt) / 1000) : 0;
+  const rate = stats.actions > 1 && stats.firstAt && stats.lastAt > stats.firstAt
+    ? ((stats.actions - 1) / ((stats.lastAt - stats.firstAt) / 1000)).toFixed(1) : null;
+  return (
+    <section className="mk-stage-wrap" aria-label="The game">
+      <div className={'mk-stage' + (frame ? ' has-frame' : '')}>
+        {frame
+          ? <img className="mk-frame" src={frame} alt="The frame of the browser the model is playing in" />
+          : <Empty harness={harness} status={status} running={running} onPlay={onPlay} />}
+        {frame && (
+          <div className="mk-hud">
+            {running
+              ? <span className="mk-live"><span className="mk-live-dot" aria-hidden="true" />Live{fps > 0 ? ` · ${fps} fps` : ''}</span>
+              : <span className="mk-live">{statusLabel(status)}</span>}
+            <span className="mk-hud-spacer" />
+            {stats.actions > 0 && <Stat label="actions" value={stats.actions} />}
+            {rate && <Stat label="a second" value={rate} />}
+            {stats.lives != null && <Stat label="deaths" value={stats.deaths} />}
+            {elapsed > 0 && <Stat label="s" value={elapsed} />}
+            {running && (
+              <button type="button" className="btn mk-stop" onClick={onStop}>
+                <Square size={12} aria-hidden="true" />Stop
+              </button>
+            )}
+          </div>
+        )}
+      </div>
+      <p className="mk-credits">
+        The game is <a href="https://supermarioplay.com/game/mario.html?v=1.0.1" target="_blank" rel="noopener noreferrer">Full Screen Mario at supermarioplay.com</a>;
+        Mario belongs to Nintendo and none of the game's files ship here. The browser is driven with <a href="https://github.com/browser-use/browser-use" target="_blank" rel="noopener noreferrer">Browser Use</a> (MIT).
+        The model is <a href="https://typesafe.ai" target="_blank" rel="noopener noreferrer">Jev</a> by TypeSafe, a System One model, through OpenRouter.
+        The harness is the open-source <a href="https://github.com/HarnessRouter/SystemOneHarness" target="_blank" rel="noopener noreferrer">System One Harness</a>.
+      </p>
+      <div className="mk-facts" aria-label="How it works">
+        <div className="mk-fact">
+          <div className="mk-fact-k"><Eye size={14} aria-hidden="true" />Reads the game, not the screen</div>
+          <div className="mk-fact-v">Each step the environment states where Mario is and what is ahead, in tiles, as a few plain sentences, and which hold clears the wall.</div>
+        </div>
+        <div className="mk-fact">
+          <div className="mk-fact-k"><Zap size={14} aria-hidden="true" />Decides, never writes</div>
+          <div className="mk-fact-v">A System One model picks one control from that state, a few hundred milliseconds a decision, with no screenshot and no text generation.</div>
+        </div>
+        <div className="mk-fact">
+          <div className="mk-fact-k"><Keyboard size={14} aria-hidden="true" />Plays a real browser</div>
+          <div className="mk-fact-v">The keys are held in a browser inside this deployment, driven with Browser Use. What you watch is that browser's own frame.</div>
+        </div>
+      </div>
+    </section>
+  );
+}
diff --git a/kits/mario/app/src/components/Topbar.jsx b/kits/mario/app/src/components/Topbar.jsx
new file mode 100644
index 0000000..3840442
--- /dev/null
+++ b/kits/mario/app/src/components/Topbar.jsx
@@ -0,0 +1,86 @@
+// The app bar: the way back to HarnessRouter, the kit's name, what is playing and how it is
+// going, a new run, and who is signed in.
+//
+// Same bar as the other kits. The model chip is this kit's addition: which System One model is
+// playing is the fact about the run, so it is read from the harness rather than written here.
+import { useEffect, useRef, useState } from 'react';
+import { ArrowLeft, BookOpen, Cpu, LogOut, RotateCcw } from 'lucide-react';
+import { Popover } from 'reifyui';
+import { getSession, logout, SESSION_EVENT } from '../lib/auth';
+import { CONSOLE_HOME } from '../lib/kit';
+import { statusLabel } from '../lib/game';
+import { MkMark } from './MkMark';
+
+export const LINKS = {
+  docs: 'https://github.com/HarnessRouter/starter-kit/tree/main/kits/mario',
+};
+
+export function AvatarMenu() {
+  const [open, setOpen] = useState(false);
+  const [session, setSession] = useState(getSession);
+  const btnRef = useRef(null);
+
+  useEffect(() => {
+    const sync = () => setSession(getSession());
+    window.addEventListener(SESSION_EVENT, sync);
+    return () => window.removeEventListener(SESSION_EVENT, sync);
+  }, []);
+
+  const member = session?.member;
+  if (!member) return null;
+  const displayName = member.display_name || member.name || member.email || 'Account';
+  const initial = String(displayName).trim().charAt(0).toUpperCase() || 'U';
+
+  return (
+    <>
+      <button ref={btnRef} className="av" onClick={() => setOpen((v) => !v)}
+              aria-label="Account menu" aria-expanded={open}>{initial}</button>
+      <Popover open={open} anchorRef={btnRef} onClose={() => setOpen(false)}
+               width={220} minHeight={110} label="Account">
+        <div className="mk-who">{displayName}</div>
+        <a className="uic-pop-item" href={LINKS.docs} target="_blank" rel="noreferrer">
+          <BookOpen size={15} />Documentation
+        </a>
+        {session.gated && (
+          <button type="button" className="uic-pop-item mk-danger" onClick={logout}>
+            <LogOut size={15} />Log out
+          </button>
+        )}
+      </Popover>
+    </>
+  );
+}
+
+function StatusChip({ status }) {
+  const cls = status === 'running' ? ' is-live' : status === 'completed' ? ' is-ok'
+    : status === 'failed' ? ' is-bad' : '';
+  return (
+    <span className={'mk-chip mk-status' + cls}>
+      {status === 'running' && <span className="mk-dot" aria-hidden="true" />}
+      {statusLabel(status)}
+    </span>
+  );
+}
+
+export function Topbar({ model, status, running, onNewRun }) {
+  return (
+    <header className="uic-topbar mk-topbar">
+      <a className="mk-back" href={CONSOLE_HOME} title="Back to HarnessRouter">
+        <ArrowLeft size={15} aria-hidden="true" /><span className="lbl">HarnessRouter</span>
+      </a>
+      <span className="mk-sep" aria-hidden="true" />
+      <span className="uic-wordmark"><MkMark size={22} /><span className="wm-text">Super Mario</span></span>
+      <div className="uic-topbar-spacer" />
+      {model && (
+        <span className="mk-chip mk-model" title="The System One model playing">
+          <Cpu size={13} aria-hidden="true" /><span className="mk-chip-t">{model}</span>
+        </span>
+      )}
+      <StatusChip status={status} />
+      <button type="button" className="btn" onClick={onNewRun} disabled={running} title="Start over with a new run">
+        <RotateCcw size={14} aria-hidden="true" /><span className="lbl">New run</span>
+      </button>
+      <AvatarMenu />
+    </header>
+  );
+}
diff --git a/kits/mario/app/src/lib/auth.js b/kits/mario/app/src/lib/auth.js
new file mode 100644
index 0000000..fa095e5
--- /dev/null
+++ b/kits/mario/app/src/lib/auth.js
@@ -0,0 +1,29 @@
+// Identity, borrowed rather than built: the console authenticated whoever is looking at this app
+// before it was served, and the browser carries that session on every same-origin request.
+export const SESSION_EVENT = 'mario:session';
+
+let _session = null;
+let _asked = false;
+
+/** Who the console says is signed in. Null until the first load resolves. */
+export function getSession() {
+  if (!_asked) {
+    _asked = true;
+    fetch('/api/selfhost/session', { cache: 'no-store' })
+      .then((r) => (r.ok ? r.json() : null))
+      .then((d) => {
+        if (!d?.user) return;
+        _session = { member: { email: d.user, id: d.user }, gated: Boolean(d.gated) };
+        window.dispatchEvent(new CustomEvent(SESSION_EVENT));
+      })
+      .catch(() => {});
+  }
+  return _session;
+}
+
+/** The console owns the session, so signing out is its business, not this app's. */
+export function logout() {
+  fetch('/api/selfhost/logout', { method: 'POST' })
+    .catch(() => {})
+    .finally(() => { window.location.href = '/'; });
+}
diff --git a/kits/mario/app/src/lib/frames.js b/kits/mario/app/src/lib/frames.js
new file mode 100644
index 0000000..6b20aa1
--- /dev/null
+++ b/kits/mario/app/src/lib/frames.js
@@ -0,0 +1,78 @@
+// The frame, as a stream of reads.
+//
+// The environment writes frame.jpg about twenty times a second; the only way to it from here is
+// the session's live workspace read, one request a frame. So this keeps a few requests in flight
+// at once (the round trip to the deployment is what bounds the rate, not the file), shows each
+// frame only once it has decoded, and drops any that arrives after a newer one. What the hook
+// reports as the rate is the rate of frames it actually showed.
+import { useEffect, useState } from 'react';
+import { frameUrl } from './game.js';
+
+const IN_FLIGHT = 3;
+const GAP_MS = 70;
+const AFTER_MS = 2500;      // keep reading this long after the run ends, for the last frames
+
+export function useFrames(sessionId, active) {
+  const [frame, setFrame] = useState(null);
+  const [fps, setFps] = useState(0);
+
+  useEffect(() => {
+    if (!sessionId) { setFrame(null); setFps(0); return undefined; }
+    let stopped = false;
+    let inFlight = 0;
+    let seq = 0;
+    let shown = 0;
+    let shownAt = 0;
+    let missing = 0;
+    let count = 0;
+    let since = performance.now();
+    const activeUntil = { t: active ? Infinity : performance.now() + AFTER_MS };
+    const url = frameUrl(sessionId);
+
+    const read = async () => {
+      const n = ++seq;
+      inFlight += 1;
+      try {
+        const r = await fetch(`${url}?n=${n}`, { cache: 'no-store' });
+        if (stopped) return;
+        if (!r.ok) { missing += 1; return; }
+        missing = 0;
+        if (n <= shown) return;
+        const blob = await r.blob();
+        const u = URL.createObjectURL(blob);
+        const im = new Image();
+        im.onload = () => {
+          if (stopped || n <= shown) { URL.revokeObjectURL(u); return; }
+          shown = n; shownAt = performance.now(); count += 1;
+          setFrame((old) => { if (old) URL.revokeObjectURL(old); return u; });
+        };
+        im.onerror = () => URL.revokeObjectURL(u);
+        im.src = u;
+      } catch { /* the next read is the retry */ } finally { inFlight -= 1; }
+    };
+
+    const timer = setInterval(() => {
+      if (stopped || inFlight >= IN_FLIGHT) return;
+      // before the first frame the browser is still starting: look, but gently
+      if (shown === 0 && missing > 0 && inFlight > 0) return;
+      if (performance.now() > activeUntil.t) return;
+      read();
+    }, GAP_MS);
+    const meter = setInterval(() => {
+      const dt = (performance.now() - since) / 1000;
+      setFps(dt > 0 ? Math.round(count / dt) : 0);
+      count = 0; since = performance.now();
+      if (shownAt && performance.now() - shownAt > 3000) setFps(0);
+    }, 1000);
+
+    return () => {
+      stopped = true;
+      clearInterval(timer);
+      clearInterval(meter);
+    };
+  }, [sessionId, active]);
+
+  useEffect(() => () => { setFrame((old) => { if (old) URL.revokeObjectURL(old); return null; }); }, [sessionId]);
+
+  return { frame, fps };
+}
diff --git a/kits/mario/app/src/lib/game.js b/kits/mario/app/src/lib/game.js
new file mode 100644
index 0000000..517bfe8
--- /dev/null
+++ b/kits/mario/app/src/lib/game.js
@@ -0,0 +1,54 @@
+// The data layer. Everything about talking to HarnessRouter lives in `reifyui/harness`; this file
+// is only what a game run adds on top of it:
+//
+//   a run        = a session on this kit's harness
+//   its frame    = frame.jpg in that session's workspace, written by the environment as the
+//                  browser draws (the live workspace, so the file is read as it is written)
+//   its figures  = what the environment states at the end of every observation
+import {
+  cancelResponse, configureKit, kitConfig, kitHarness, sessionDetail, sessionTurns,
+} from 'reifyui/harness';
+import { FRAME_FILE, KIT_ID } from './kit.js';
+
+configureKit({ kitId: KIT_ID });
+
+export { cancelResponse, sessionDetail, sessionTurns };
+
+/** The harness this kit launched, or null when it was never launched. */
+export const gameHarness = kitHarness;
+
+/** A run that has been opened but not started: no session exists until the first message. */
+export const PENDING = 'new';
+export const isPending = (id) => !id || id === PENDING;
+
+export function frameUrl(sessionId) {
+  return `${kitConfig().base}/sessions/${encodeURIComponent(sessionId)}/files/${FRAME_FILE}`;
+}
+
+/** Whether a session's turn is in flight, from the session record. */
+export function turnRunning(detail) {
+  const s = String(detail?.turn_status || detail?.status || '');
+  return s === 'running' || s === 'in_progress' || s === 'queued' || s === 'starting';
+}
+
+/** The figures the environment states at the end of every observation, or null when the text is
+ *  not one of its observations. */
+export function readObservation(text) {
+  const t = String(text || '');
+  const m = /Lives (\d+), time (\d+), score (\d+)\./.exec(t);
+  if (m) return { lives: +m[1], time: +m[2], score: +m[3] };
+  const d = /Mario has just died\. Lives left: (\d+)/.exec(t);
+  return d ? { lives: +d[1] } : null;
+}
+
+/** The turn's terminal status, in the person's terms. */
+export function statusLabel(status) {
+  switch (status) {
+    case 'running': return 'Playing';
+    case 'completed': return 'Finished';
+    case 'incomplete': return 'Reached the limit';
+    case 'cancelled': return 'Stopped';
+    case 'failed': return 'Failed';
+    default: return 'Ready';
+  }
+}
diff --git a/kits/mario/app/src/lib/kit.js b/kits/mario/app/src/lib/kit.js
new file mode 100644
index 0000000..6996db7
--- /dev/null
+++ b/kits/mario/app/src/lib/kit.js
@@ -0,0 +1,17 @@
+// The kit's own name, in one place: the route the console serves this app at, the `base` vite
+// writes into every asset URL, and the `kit` field the gateway reports for the harness this kit
+// launched all have to agree, or the app cannot find its own backend.
+export const KIT_ID = 'mario';
+
+/** Where the console serves this app. Vite's `base`. */
+export const KIT_BASE = `/kits/${KIT_ID}/`;
+
+/** The console this app was opened from; the way back. */
+export const CONSOLE_HOME = '/';
+export const CONSOLE_KITS = '/kits';
+
+/** The frame the environment writes into the session's workspace, about twenty times a second. */
+export const FRAME_FILE = 'frame.jpg';
+
+/** The first message of a run when it is started with the Play button. */
+export const DEFAULT_GOAL = 'Play the level: keep running right, jump over enemies, gaps and pipes, and get as far as you can.';
diff --git a/kits/mario/app/src/main.jsx b/kits/mario/app/src/main.jsx
new file mode 100644
index 0000000..f100ae8
--- /dev/null
+++ b/kits/mario/app/src/main.jsx
@@ -0,0 +1,12 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App.jsx';
+import 'reifyui/styles/panels.css';
+import 'reifyui/styles/chat.css';
+import 'reifyui/styles/dialog.css';
+import 'reifyui/styles/library.css';
+import 'reifyui/styles/chip.css';
+import './styles/tokens.css';
+import './styles/app.css';
+
+createRoot(document.getElementById('root')).render(<StrictMode><App /></StrictMode>);
diff --git a/kits/mario/app/src/pages/GamePage.jsx b/kits/mario/app/src/pages/GamePage.jsx
new file mode 100644
index 0000000..1392314
--- /dev/null
+++ b/kits/mario/app/src/pages/GamePage.jsx
@@ -0,0 +1,131 @@
+// One run: the stage on the left, the conversation on the right.
+//
+// Two loops run here. The CONVERSATION loop is one open stream, in ChatPanel; this page listens
+// to its events to count the run. The FRAME loop reads frame.jpg from the session's live
+// workspace while a turn is in flight (see lib/frames.js). Nothing else on this page polls.
+import { useCallback, useEffect, useMemo, useReducer, useState } from 'react';
+import { PaneResizer, useResizablePane } from 'reifyui';
+import { cancelResponse, gameHarness, isPending, readObservation, sessionDetail, turnRunning } from '../lib/game';
+import { DEFAULT_GOAL } from '../lib/kit';
+import { useFrames } from '../lib/frames';
+import { Stage } from '../components/Stage';
+import { ChatColumn } from '../components/ChatColumn';
+import { Topbar } from '../components/Topbar';
+
+const FRESH = { actions: 0, firstAt: 0, lastAt: 0, deaths: 0, lives: null, startedAt: 0, endedAt: 0 };
+
+function count(stats, ev) {
+  switch (ev.type) {
+    case 'start': return { ...FRESH, startedAt: Date.now() };
+    case 'call': {
+      const now = Date.now();
+      return { ...stats, actions: stats.actions + 1, firstAt: stats.firstAt || now, lastAt: now };
+    }
+    case 'result': {
+      const obs = ev.obs;
+      if (!obs || obs.lives == null) return stats;
+      const died = stats.lives != null && obs.lives < stats.lives;
+      return { ...stats, lives: obs.lives, deaths: stats.deaths + (died ? 1 : 0) };
+    }
+    case 'end': return { ...stats, endedAt: Date.now() };
+    default: return stats;
+  }
+}
+
+export function GamePage({ id: routeId }) {
+  // The session id lives in state, not in the route: a run starts pending and becomes a session
+  // when its first turn opens one, which arrives while the stream is open.
+  const [id, setId] = useState(routeId);
+  useEffect(() => { setId(routeId); }, [routeId]);
+
+  const [harness, setHarness] = useState(undefined);   // undefined = unknown, null = not launched
+  // Play hands the panel a first message. The panel sends a seed only as it opens on a session,
+  // so Play also remounts it (nothing is lost: the conversation is empty until then).
+  const [seed, setSeed] = useState('');
+  const [runKey, setRunKey] = useState(0);
+  const [status, setStatus] = useState('');
+  const [rid, setRid] = useState('');
+  const [externalBusy, setExternalBusy] = useState(false);
+  const [stats, dispatch] = useReducer(count, FRESH);
+  const [chatOpen, setChatOpen] = useState(() => window.innerWidth > 900);
+  const chatPane = useResizablePane({
+    initial: 400, min: 320, maxFraction: 0.5, fromRight: true, storageKey: 'mario.chat.w',
+  });
+
+  useEffect(() => {
+    gameHarness().then((h) => setHarness(h || null)).catch(() => setHarness(null));
+  }, []);
+
+  // A run opened from its link while its turn is still going: the panel polls history while
+  // this is true, and the frames keep coming.
+  useEffect(() => {
+    if (isPending(id)) return undefined;
+    let on = true;
+    const look = async () => {
+      const d = await sessionDetail(id).catch(() => null);
+      if (!on) return;
+      const busy = turnRunning(d);
+      setExternalBusy(busy);
+      if (busy) setTimeout(look, 2000);
+    };
+    look();
+    return () => { on = false; };
+  }, [id]);
+
+  const running = status === 'running';
+  const { frame, fps } = useFrames(isPending(id) ? '' : id, running || externalBusy);
+
+  const handlers = useMemo(() => ({
+    onCreated: (r) => { setRid(r); setStatus('running'); dispatch({ type: 'start' }); },
+    onToolCall: () => dispatch({ type: 'call' }),
+    onToolResult: (_, output) => dispatch({ type: 'result', obs: readObservation(output) }),
+    onDone: (s) => { setStatus(s); dispatch({ type: 'end' }); },
+    onError: () => { setStatus('failed'); dispatch({ type: 'end' }); },
+  }), []);
+
+  const onStop = useCallback(() => { if (rid) cancelResponse(rid).catch(() => {}); }, [rid]);
+  const onNewRun = useCallback(() => {
+    window.location.hash = '#/';
+    if (isPending(id)) { setStatus(''); setRid(''); dispatch({ type: 'end' }); }
+  }, [id]);
+
+  return (
+    <div className="mk-root">
+      <Topbar model={harness?.defaultModel || ''} status={status} running={running} onNewRun={onNewRun} />
+      <div className="mk-body">
+        <main className="mk-main scroll">
+          <Stage
+            frame={frame}
+            fps={fps}
+            harness={harness}
+            status={status}
+            running={running || externalBusy}
+            stats={stats}
+            onPlay={() => { setSeed(DEFAULT_GOAL); setRunKey((k) => k + 1); }}
+            onStop={onStop}
+          />
+        </main>
+
+        <PaneResizer pane={chatPane} />
+
+        {/* Keyed on the Play count only: the run's id arrives WHILE the stream is open, and a key
+            that carried it remounted the panel at that moment and dropped the live steps. */}
+        <ChatColumn
+          key={runKey}
+          runId={id}
+          seed={seed}
+          onSeedConsumed={() => setSeed('')}
+          handlers={handlers}
+          externalBusy={externalBusy}
+          onSessionStarted={(sid) => {
+            setId(sid);
+            window.history.replaceState(null, '', `${window.location.pathname}#/r/${encodeURIComponent(sid)}`);
+          }}
+          width={chatPane.width}
+          collapsed={!chatOpen}
+          onToggle={() => setChatOpen((v) => !v)}
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/kits/mario/app/src/styles/app.css b/kits/mario/app/src/styles/app.css
new file mode 100644
index 0000000..7cb8029
--- /dev/null
+++ b/kits/mario/app/src/styles/app.css
@@ -0,0 +1,104 @@
+/* Super Mario: what this app composes for itself.
+ *
+ * The shell, the app bar, the conversation column and the popovers come from reifyui and are
+ * styled by library.css / chat.css / panels.css. What is here is only the part that is about
+ * WATCHING A GAME: the stage the frame plays on, the figures over it, and how the bar sheds its
+ * contents as it narrows.
+ */
+
+/* ── The page ─────────────────────────────────────────────────────────── */
+.mk-root { height: 100vh; display: flex; flex-direction: column; background: var(--bg); overflow: hidden; }
+.mk-body { flex: 1; min-height: 0; display: flex; }
+.mk-main {
+  flex: 1; min-width: 0; min-height: 0; display: flex; flex-direction: column; gap: 12px;
+  padding: 18px 22px 16px; overflow: auto;
+}
+
+/* ── The app bar ──────────────────────────────────────────────────────── */
+.mk-back {
+  display: inline-flex; align-items: center; gap: 6px; height: 30px; padding: 0 9px;
+  border-radius: 7px; color: var(--mute); text-decoration: none; font-size: 13px; white-space: nowrap;
+}
+.mk-back:hover { background: var(--line-soft); color: var(--ink); }
+.mk-sep { width: 1px; height: 20px; background: var(--line); flex-shrink: 0; }
+.mk-chip {
+  display: inline-flex; align-items: center; gap: 6px; padding: 4px 9px; min-width: 0;
+  border-radius: var(--r-pill); font-size: 12px; white-space: nowrap;
+  background: var(--surface); color: var(--ink-2); border: 1px solid var(--line);
+}
+.mk-chip-t { min-width: 0; overflow: hidden; text-overflow: ellipsis; max-width: 22ch; }
+.mk-chip.is-live { background: var(--brand-50); color: var(--brand-ink); border-color: var(--brand-soft); }
+.mk-chip.is-ok { background: var(--ok-soft); color: #047857; border-color: #A7F3D0; }
+.mk-chip.is-bad { background: var(--hot-soft); color: #B91C1C; border-color: #FCA5A5; }
+.mk-dot { width: 7px; height: 7px; border-radius: 999px; background: var(--brand); animation: mk-blink 1.2s ease-in-out infinite; }
+@keyframes mk-blink { 0%, 100% { opacity: .35; } 50% { opacity: 1; } }
+.mk-who { padding: 10px 12px 8px; font-size: 13px; font-weight: 600; color: var(--ink); }
+.mk-danger { color: #B91C1C; }
+
+/* ── The stage ────────────────────────────────────────────────────────── */
+.mk-stage-wrap { display: flex; flex-direction: column; gap: 10px; }
+/* Fills the column's width and keeps the game's shape; when the window is short it yields height
+   first and the picture letterboxes inside. */
+.mk-stage {
+  position: relative; width: 100%; aspect-ratio: 16 / 10; max-height: calc(100vh - 56px - 120px);
+  min-height: 220px; background: #0B1020; border-radius: 16px; overflow: hidden;
+  display: flex; align-items: center; justify-content: center;
+  box-shadow: 0 30px 60px -32px rgba(15, 23, 42, .55), 0 0 0 1px rgba(15, 23, 42, .06);
+}
+.mk-frame { width: 100%; height: 100%; object-fit: contain; display: block; image-rendering: pixelated; }
+
+.mk-hud {
+  position: absolute; left: 0; right: 0; bottom: 0;
+  display: flex; align-items: center; gap: 16px; padding: 22px 16px 12px;
+  background: linear-gradient(to top, rgba(6, 9, 22, .88), rgba(6, 9, 22, 0));
+  color: #E5E7EB; font-size: 12px;
+}
+.mk-live { display: inline-flex; align-items: center; gap: 7px; font-size: 11px; font-weight: 700; letter-spacing: .06em; text-transform: uppercase; white-space: nowrap; }
+.mk-live-dot { width: 8px; height: 8px; border-radius: 999px; background: #EF4444; box-shadow: 0 0 0 3px rgba(239, 68, 68, .25); animation: mk-blink 1.2s ease-in-out infinite; }
+.mk-hud-spacer { flex: 1; }
+.mk-stat { display: inline-flex; align-items: baseline; gap: 5px; white-space: nowrap; }
+.mk-stat b { font-variant-numeric: tabular-nums; font-weight: 600; color: #fff; font-size: 13px; }
+.mk-stat span { color: #A3A9B8; }
+.btn.mk-stop { height: 28px; padding: 0 10px; background: rgba(255, 255, 255, .12); border-color: rgba(255, 255, 255, .22); color: #fff; }
+.btn.mk-stop:hover { background: rgba(255, 255, 255, .2); }
+
+.mk-empty {
+  display: flex; flex-direction: column; align-items: center; gap: 10px; text-align: center;
+  color: #B8C0D0; font-size: 13.5px; line-height: 1.5; padding: 24px; max-width: 46ch;
+}
+.mk-empty-t { font-size: 19px; font-weight: 600; color: #fff; letter-spacing: -.01em; }
+.mk-play { height: 44px; padding: 0 24px; margin-top: 6px; font-size: 15px; font-weight: 600; border-radius: 999px; gap: 8px; }
+.mk-pulse { width: 10px; height: 10px; border-radius: 999px; background: var(--brand); animation: mk-blink 1.4s ease-in-out infinite; }
+@media (prefers-reduced-motion: reduce) { .mk-dot, .mk-live-dot, .mk-pulse { animation: none; } }
+
+.mk-credits { margin: 0; font-size: 12px; line-height: 1.55; color: var(--mute); }
+.mk-credits a { color: var(--ink-2); }
+
+.mk-facts { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 12px; margin-top: 4px; }
+.mk-fact { background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-card); padding: 12px 14px; box-shadow: var(--shadow-1); min-width: 0; }
+.mk-fact-k { display: flex; align-items: center; gap: 7px; font-size: 11.5px; font-weight: 700; color: var(--brand-ink); text-transform: uppercase; letter-spacing: .05em; margin-bottom: 5px; }
+.mk-fact-v { font-size: 12.5px; color: var(--ink-2); line-height: 1.5; }
+
+/* ── Narrow ───────────────────────────────────────────────────────────── */
+/* Keep-priority in the app bar as space runs out: the status > the model > the brand text >
+   the labels on the buttons. */
+.uic-topbar { container-type: inline-size; }
+@container (max-width: 760px) { .uic-topbar .mk-chip-t { max-width: 12ch; } }
+@container (max-width: 640px) {
+  .uic-topbar .wm-text { display: none; }
+  .uic-topbar .btn .lbl, .uic-topbar .mk-back .lbl { display: none; }
+  .uic-topbar .btn { padding: 0 9px; }
+}
+@container (max-width: 460px) { .uic-topbar .mk-model { display: none; } }
+@media (max-width: 1100px) { .mk-facts { grid-template-columns: 1fr; } }
+@media (max-width: 900px) {
+  .mk-main { padding: 12px 12px 12px; gap: 10px; }
+  .mk-stage { border-radius: 12px; max-height: calc(100vh - 56px - 96px); }
+  .mk-hud { gap: 10px; padding: 18px 12px 10px; }
+  .mk-stat span { display: none; }
+}
+@media (max-width: 640px) {
+  .uic-topbar { padding: 0 10px; gap: 6px; }
+  .mk-empty { padding: 16px; font-size: 13px; }
+  .mk-empty-t { font-size: 16px; }
+}
diff --git a/kits/mario/app/src/styles/tokens.css b/kits/mario/app/src/styles/tokens.css
new file mode 100644
index 0000000..869796c
--- /dev/null
+++ b/kits/mario/app/src/styles/tokens.css
@@ -0,0 +1,107 @@
+/* Super Mario design tokens: the token contract the other kits use, re-keyed to this kit's accent
+   (kit.json: #E4572E). Flat colours, no gradients in the chrome. The stage is the one dark surface,
+   because what it shows is the game's own picture and the frame around it should get out of the
+   way. */
+:root {
+  --brand: #E4572E;
+  --brand-ink: #C4441E;
+  --brand-soft: #F8C9B8;
+  --brand-50: #FDEFE9;
+
+  --hot-soft: #FEE4E4;
+  --warm: #F59E0B;
+  --warm-soft: #FEF1D6;
+  --ok: #10B981;
+  --ok-soft: #DFF6EC;
+
+  --bg: #F7F8FB;
+  --surface: #FFFFFF;
+  --surface-2: #FAFBFD;
+
+  --ink: #111827;
+  --ink-2: #374151;
+  --mute: #6B7280;
+  --mute-2: #9CA3AF;
+  --line: #E5E7EB;
+  --line-soft: #EFF1F4;
+
+  --r-card: 12px;
+  --r-input: 8px;
+  --r-pill: 999px;
+
+  --shadow-1: 0 1px 2px rgba(17,24,39,.04), 0 1px 1px rgba(17,24,39,.03);
+  --shadow-2: 0 8px 24px -12px rgba(17,24,39,.12), 0 2px 6px -2px rgba(17,24,39,.06);
+
+  --font: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Helvetica, Arial, sans-serif;
+  --mono: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
+}
+
+/* The shared components read --uic-* tokens; the whole contract is mapped, so an unmapped token
+   cannot fall through to the package's own default and ship as a near-miss. */
+:root {
+  --uic-bg: var(--bg);
+  --uic-surface: var(--surface);
+  --uic-surface-2: var(--surface-2);
+  --uic-line: var(--line);
+  --uic-line-soft: var(--line-soft);
+  --uic-line-strong: #CBD0DA;
+  --uic-ink: var(--ink);
+  --uic-ink-2: var(--ink-2);
+  --uic-mute: var(--mute);
+  --uic-mute-2: var(--mute-2);
+  --uic-brand: var(--brand);
+  --uic-brand-ink: var(--brand-ink);
+  --uic-brand-soft: var(--brand-soft);
+  --uic-brand-faint: var(--brand-50);
+  --uic-on-brand: #FFFFFF;
+  --uic-ok: var(--ok);
+  --uic-warn: var(--warm);
+  --uic-warn-bg: var(--warm-soft);
+  --uic-fail-ink: #B91C1C;
+  --uic-fail-line: #FCA5A5;
+  --uic-fail-bg: var(--hot-soft);
+  --uic-mono: var(--mono);
+  /* The conversation becomes a drawer below 900px; it starts under the app bar. */
+  --uic-chat-drawer-top: 56px;
+  --uic-shadow-1: var(--shadow-1);
+  --uic-shadow-2: var(--shadow-2);
+  --uic-shadow-3: -16px 0 40px rgba(15, 23, 42, .22);
+  --uic-focus-ring: color-mix(in srgb, var(--brand) 14%, transparent);
+  --uic-hover-wash: rgba(0, 0, 0, .05);
+  --uic-status-pulse: color-mix(in srgb, var(--brand) 45%, transparent);
+  --uic-skel: var(--line);
+  --uic-r-card: var(--r-card);
+  --uic-r-input: var(--r-input);
+  --uic-r-pill: var(--r-pill);
+  --uic-scrim: rgba(17, 24, 39, .42);
+  --uic-z-overlay: 9000;
+}
+
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; }
+body { font-family: var(--font); color: var(--ink); background: var(--bg); -webkit-font-smoothing: antialiased; }
+
+/* The primitives this app renders itself: a button, an avatar, a scrollbar. Everything else
+   comes from reifyui. */
+.btn {
+  display: inline-flex; align-items: center; justify-content: center; gap: 6px;
+  height: 32px; padding: 0 12px; border-radius: var(--r-input);
+  font-size: 13px; font-weight: 500; color: var(--ink-2);
+  background: #fff; border: 1px solid var(--line); cursor: pointer;
+  font-family: inherit; white-space: nowrap; text-decoration: none;
+}
+.btn:hover { border-color: #CBD0DA; }
+.btn.primary { background: var(--brand); border-color: var(--brand); color: #fff; }
+.btn.primary:hover { background: var(--brand-ink); }
+.btn:disabled, .btn[disabled] { opacity: .5; cursor: not-allowed; pointer-events: none; }
+
+.av {
+  width: 32px; height: 32px; border-radius: 999px; background: var(--brand);
+  color: #fff; font-size: 12px; font-weight: 600;
+  display: inline-flex; align-items: center; justify-content: center; flex-shrink: 0;
+  border: none; cursor: pointer; font-family: inherit;
+}
+
+.scroll::-webkit-scrollbar { width: 8px; height: 8px; }
+.scroll::-webkit-scrollbar-thumb { background: #D7DBE3; border-radius: 999px; }
+.scroll::-webkit-scrollbar-track { background: transparent; }
diff --git a/kits/mario/app/vite.config.js b/kits/mario/app/vite.config.js
new file mode 100644
index 0000000..7916e9a
--- /dev/null
+++ b/kits/mario/app/vite.config.js
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { KIT_BASE } from './src/lib/kit.js';
+
+// Served from the HarnessRouter image at /kits/<kit> (see docker/install-kits.sh), so assets must
+// be requested from there rather than from the root.
+export default defineConfig({
+  base: KIT_BASE,
+  plugins: [react()],
+  build: { outDir: 'dist', emptyOutDir: true },
+});
diff --git a/kits/mario/kit.json b/kits/mario/kit.json
index be82ce2..d5515b8 100644
--- a/kits/mario/kit.json
+++ b/kits/mario/kit.json
@@ -2,25 +2,34 @@
   "id": "mario",
   "title": "Super Mario",
   "tagline": "A System One model plays a platform game several times a second, and you watch its browser.",
-  "description": "Full Screen Mario runs in a headless browser inside this deployment. The System One base reads the game's own state each step as a few literal sentences (where Mario is, what is ahead and how far) and chooses one control to hold, a few hundred milliseconds a decision, with no screenshot and no text generation. The left pane shows the frame of the browser the model is playing in; the right pane is the harness. Credits: the game is Full Screen Mario, played at supermarioplay.com; the browser is driven with Browser Use (MIT); the model is TypeSafe's Jev through OpenRouter.",
+  "description": "Full Screen Mario runs in a headless browser inside this deployment. The System One base reads the game's own state each step as a few literal sentences (where Mario is, what is ahead and how far) and chooses one control to hold, a few hundred milliseconds a decision, with no screenshot and no text generation. The left pane streams the browser the model is playing in; the right pane is the run's conversation, every decision with the game's reply. Credits: the game is Full Screen Mario, played at supermarioplay.com; the browser is driven with Browser Use (MIT); the model is TypeSafe's Jev through OpenRouter.",
   "icon": "tabler:device-gamepad-2",
   "accent": "#E4572E",
   "harness": {
     "name": "Super Mario",
     "base": "systemone",
     "recommended": [
-      { "base": "systemone", "model": "jev-1.13" },
-      { "base": "systemone", "model": "jev-latest" }
+      {
+        "base": "systemone",
+        "model": "jev-1.13"
+      },
+      {
+        "base": "systemone",
+        "model": "jev-latest"
+      }
     ],
     "plugin": "plugin",
     "mcp_servers": [],
-    "system_prompt": "You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. Keep moving right. Jump over an enemy when it is within 3 tiles, over a gap when its edge is within 2 tiles, and over a pipe or wall when it is within 2 tiles; hold the jump longer for a taller wall or a wider gap. Finish when the level is cleared. Escalate when Mario has no lives left."
+    "system_prompt": "You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. Keep moving right. The state names any enemy, gap or wall that is within one step: jump over it now with jump_right, held as long as the state says. Otherwise run right. When Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left."
   },
   "app": {
+    "dir": "app",
+    "build": "npm ci && npm run build",
+    "dist": "dist",
     "route": "/kits/mario"
   },
   "session": {
-    "$comment": "One session is one run of the game. The frame the page shows is frame.jpg in the session's workspace, written by the environment on every step.",
+    "$comment": "One session is one run of the game. The frame the page streams is frame.jpg in the session's workspace, written by the environment about twenty times a second from the browser's own screencast.",
     "artifact": "frame.jpg",
     "title_from": "meta.title"
   }
diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index a937446..ee56619 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -16,6 +16,7 @@
 """
 
 import asyncio
+import base64
 import glob
 import os
 import pathlib
@@ -35,15 +36,27 @@
 INSTRUCTIONS = ("You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on "
                 "the ground, and what is ahead with distances in tiles. One step lasts about half a second and "
                 "covers up to 4 tiles at a run. Keep moving right. The state names any enemy, gap or wall that is "
-                "within one step: jump over it now, with jump_right; hold the jump longer for a taller wall or a "
-                "wider gap. Otherwise run right. When Mario has just died, wait. Finish when the level is cleared. "
-                "Escalate when Mario has no lives left.")
+                "within one step: jump over it now, with jump_right, held as long as the state says (a taller "
+                "wall or a wider gap needs a longer hold). Otherwise run right. When Mario has just died, wait. "
+                "Finish when the level is cleared. Escalate when Mario has no lives left.")
+# Measured on the live game, feet above the ground at the apex: a short hold reaches 3.1 tiles, a
+# medium 3.9, a long 4.1, standing or at a run. So a 2-tile pipe takes a short hold, a 3-tile one a
+# medium, and a 4-tile one a long hold with the run-up the jump_right macro provides (from against
+# it the apex is level with the top and the side blocks the way; from 1.5 to 3 tiles back it clears).
+def hold_for(height: float) -> str:
+    return "short" if height <= 2 else "medium" if height <= 3 else "long"
+
+TALL = 4          # a wall this tall needs the run-up
+# The frame the kit's page shows: Chrome's own screencast, a JPEG for every third frame the game
+# draws (about twenty a second), each written whole to frame.jpg. The page reads that file.
+SCREENCAST = {"format": "jpeg", "quality": 45, "maxWidth": 960, "maxHeight": 600, "everyNthFrame": 3}
 
 STATE_JS = """(function(){
   if (!window.player || !window.gamescreen) return {ready: false};
   var u = window.unitsize || 4, T = 8 * u, p = player, sl = gamescreen.left, sr = gamescreen.right;
   function tiles(px){ return Math.round(px / T * 10) / 10; }
   var enemies = [], gaps = [], walls = [];
+  var ground = (window.map && map.floor) ? map.floor * u : p.bottom;   // the ground under him, not his feet: heights must not shrink mid-jump
   (window.characters || []).forEach(function(c){
     if (!c.alive || c === player || c.title === undefined) return;
     if (['Coin','Mushroom','FireFlower','Star','Vine','Text','Shell','Fireball'].indexOf(c.title) >= 0) return;
@@ -60,15 +73,20 @@
   if (gapStart !== null) gaps.push({dx: tiles(gapStart), width: tiles(12 * T - gapStart)});
   (window.solids || []).forEach(function(s){
     if (!s.alive || ['Pipe','Block','Brick','Stone'].indexOf(s.title) < 0) return;
-    var dx = (s.left - p.right) / T;
-    if (dx >= 0 && dx <= 8 && s.bottom > p.top - T && s.top < p.bottom) {
-      walls.push({kind: s.title.toLowerCase(), dx: Math.round(dx * 10) / 10, height: tiles(p.bottom - s.top)});
-    }
+    // anything whose far edge is still ahead of Mario counts, including the pipe he is pressed
+    // against (he overlaps its edge by a tenth of a tile there, and a dx >= 0 filter lost it:
+    // forty steps of "no wall within 8 tiles" against a pipe). A wall stands on the ground: what
+    // sits at or below the ground is floor, and what floats a tile or more above it (the block
+    // rows) is run under, not jumped
+    if (s.right <= p.left || s.top >= ground - 2 || s.bottom < ground - T) return;
+    var dx = Math.max(0, (s.left - p.right) / T);
+    if (dx <= 8) walls.push({kind: s.title.toLowerCase(), dx: Math.round(dx * 10) / 10, height: tiles(ground - s.top)});
   });
   enemies.sort(function(a, b){ return a.dx - b.dx; }); walls.sort(function(a, b){ return a.dx - b.dx; }); gaps.sort(function(a, b){ return a.dx - b.dx; });
+  walls = walls.filter(function(w, i){ return i === 0 || w.dx !== walls[i - 1].dx || w.height !== walls[i - 1].height; });
   var d = window.data || {};
   function amt(k){ return d[k] && d[k].amount !== undefined ? d[k].amount : null; }
-  return {ready: true, x: tiles(p.left), y: tiles((window.map && map.floor ? map.floor * u : p.bottom) - p.bottom),
+  return {ready: true, x: tiles(p.left), y: tiles(ground - p.bottom),
           dying: !!p.dying,
           screen_tiles: tiles(sr - sl), xvel: Math.round((p.xvel || 0) * 10) / 10, on_ground: !!p.resting, dead: !!p.dead,
           power: p.power || 1, enemies: enemies.slice(0, 3), gaps: gaps.slice(0, 2), walls: walls.slice(0, 2),
@@ -117,6 +135,7 @@ def __init__(self):
         self.frame_path = workspace_root() / "frame.jpg"
         self.started_at = time.time()
         self.steps = 0
+        self.frames = 0
         self._lives = None
         self._restarting_until = 0.0
         self._held: set[int] = set()
@@ -137,6 +156,8 @@ async def _start(self):
         await self._session.start()
         await self._session.navigate_to(GAME_URL)
         self._cdp = await self._session.get_or_create_cdp_session()
+        self._cdp.cdp_client.register.Page.screencastFrame(self._on_frame)
+        await self._screencast()
         for _ in range(80):
             st = await self._eval(STATE_JS)
             if isinstance(st, dict) and st.get("ready"):
@@ -144,22 +165,27 @@ async def _start(self):
             await asyncio.sleep(0.25)
         await self._eval("window.unpause && unpause(); 'ok'")
 
-    async def _eval(self, expression: str):
-        r = await self._cdp.cdp_client.send.Runtime.evaluate(params={"expression": expression, "returnByValue": True},
-                                                             session_id=self._cdp.session_id)
-        return (r.get("result") or {}).get("value")
+    async def _screencast(self) -> None:
+        await self._cdp.cdp_client.send.Page.startScreencast(params=SCREENCAST, session_id=self._cdp.session_id)
 
-    async def _frame(self) -> None:
+    def _on_frame(self, ev: dict, session_id=None) -> None:
+        """Runs on the browser loop for every screencast frame: the JPEG goes to frame.jpg whole
+        (a temp file renamed over it, so a reader never sees half a picture), and the frame is
+        acknowledged, without which Chrome stops sending."""
         try:
-            r = await self._cdp.cdp_client.send.Page.captureScreenshot(params={"format": "jpeg", "quality": 45},
-                                                                       session_id=self._cdp.session_id)
-            import base64
-            data = base64.b64decode(r["data"])
             tmp = self.frame_path.with_suffix(".jpg.tmp")
-            tmp.write_bytes(data)
+            tmp.write_bytes(base64.b64decode(ev["data"]))
             os.replace(tmp, self.frame_path)
+            self.frames += 1
         except Exception:  # noqa: BLE001 - a missed frame is a missed frame, never a failed step
             pass
+        self._loop.create_task(self._cdp.cdp_client.send.Page.screencastFrameAck(
+            params={"sessionId": ev["sessionId"]}, session_id=self._cdp.session_id))
+
+    async def _eval(self, expression: str):
+        r = await self._cdp.cdp_client.send.Runtime.evaluate(params={"expression": expression, "returnByValue": True},
+                                                             session_id=self._cdp.session_id)
+        return (r.get("result") or {}).get("value")
 
     async def _down(self, *codes: int) -> None:
         for c in codes:
@@ -186,12 +212,15 @@ async def _macro(self, name: str, hold: float) -> None:
         elif name == "jump_right":
             await self._up(L)
             await self._down(R, S)
+            await self._land()
+            await self._approach()
             await self._eval(f"keydown({U}); 'ok'")
             await asyncio.sleep(hold)
             await self._eval(f"keyup({U}); 'ok'")
             await asyncio.sleep(max(0.0, 0.75 - hold))      # the flight, run key still down
         elif name == "jump":
             await self._up(R, S, L)
+            await self._land()
             await self._eval(f"keydown({U}); 'ok'")
             await asyncio.sleep(hold)
             await self._eval(f"keyup({U}); 'ok'")
@@ -205,6 +234,84 @@ async def _macro(self, name: str, hold: float) -> None:
             await self._up(R, S, L)
             await asyncio.sleep(0.25)
 
+    async def _land(self) -> None:
+        """A jump key pressed in the air does nothing in this game, so a jump asked for mid-flight
+        is taken on landing: the action means what it says instead of being spent."""
+        for _ in range(30):
+            if await self._eval("!!player.resting || !!player.dead || !!player.dying"):
+                return
+            await asyncio.sleep(0.03)
+
+    async def _approach(self) -> None:
+        """The model decides to jump; when to leave the ground is the environment's, the way
+        holding the keys is. A decision lands every half second or so and a jump is a one-tile
+        affair, so a jump taken the moment it is chosen is early or late by luck. Measured on the
+        live game: a wall 4 tiles tall is cleared by a long jump from 1.5 to 3 tiles back and from
+        nowhere else (from against it the apex is level with the top; at a run from 4 back it
+        peaks early and hits the side); a running jump covers about 9 tiles, so an enemy jumped
+        from 4 tiles is landed well past, one jumped from 2 at a run is hit on take-off, and a gap
+        is best left from its edge. So: keep running until the nearest thing ahead is at its
+        distance, or, pressed against a tall wall with no speed, step back first."""
+        st = await self._eval(STATE_JS)
+        if not isinstance(st, dict) or not st.get("ready"):
+            return
+        target, want = self._target(st)
+        if target is None:
+            return
+        R, S, L = KEY["right"], KEY["sprint"], KEY["left"]
+        if target == "wall" and want is None:      # pressed against a tall wall, standing
+            await self._up(R, S)
+            await self._down(L)
+            for _ in range(40):
+                await asyncio.sleep(0.03)
+                st = await self._eval(STATE_JS)
+                w = ((st or {}).get("walls") or [None])[0]
+                if not w or w["dx"] >= 1.6:
+                    break
+            await self._up(L)
+            await self._down(R, S)
+            await asyncio.sleep(0.05)
+            return
+        for _ in range(34):                        # at most a second of running
+            await asyncio.sleep(0.03)
+            st = await self._eval(STATE_JS)
+            if not isinstance(st, dict) or st.get("dying") or st.get("dead"):
+                return
+            t, w = self._target(st)
+            if t != target or w is None or self._distance(st, t) <= w:
+                return
+
+    @staticmethod
+    def _distance(st: dict, kind: str) -> float:
+        rows = st.get({"enemy": "enemies", "wall": "walls", "gap": "gaps"}[kind]) or []
+        return rows[0]["dx"] if rows else 99.0
+
+    @staticmethod
+    def _target(st: dict):
+        """What the jump is for and the distance to leave the ground at: (kind, tiles), with
+        None tiles meaning jump now, and ("wall", None) meaning pressed against a tall wall."""
+        near = []
+        en, walls, gaps = st.get("enemies") or [], st.get("walls") or [], st.get("gaps") or []
+        if en and en[0]["dx"] <= 10:
+            near.append((en[0]["dx"], "enemy"))
+        if walls and walls[0]["dx"] <= 6:
+            near.append((walls[0]["dx"], "wall"))
+        if gaps and gaps[0]["dx"] <= 6:
+            near.append((gaps[0]["dx"], "gap"))
+        if not near:
+            return None, None
+        dx, kind = min(near)
+        fast = abs(st.get("xvel") or 0) >= 3
+        if kind == "wall":
+            if walls[0]["height"] < TALL:
+                return None, None                       # any distance within a step clears it
+            if dx < 1.4 and not fast and st.get("on_ground"):
+                return "wall", None
+            return "wall", 2.8
+        if kind == "enemy":
+            return ("enemy", 4.0) if fast and dx > 4.0 else (None, None)
+        return ("gap", 1.5) if dx > 1.5 else (None, None)
+
     # ── the tools ──
     def reset(self, goal: str) -> dict:
         async def go():
@@ -216,7 +323,10 @@ async def go():
                     break
                 await asyncio.sleep(0.25)
             await self._eval("window.unpause && unpause(); 'ok'")
-            await self._frame()
+            try:
+                await self._screencast()
+            except Exception:  # noqa: BLE001 - already running across the navigation
+                pass
             return {"ok": True}
         self.steps = 0
         return self._run(go())
@@ -225,7 +335,6 @@ def observe(self) -> dict:
         async def go():
             await self._start()
             st = await self._eval(STATE_JS)
-            await self._frame()
             return st if isinstance(st, dict) else {"ready": False}
         st = self._run(go())
         return self._describe(st)
@@ -260,9 +369,7 @@ async def go():
             await self._start()
             await self._macro(name, seconds)
             await asyncio.sleep(0.05)
-            st = await self._settled()
-            await self._frame()
-            return st
+            return await self._settled()
         st = self._run(go())
         self.steps += 1
         d = self._describe(st)
@@ -273,9 +380,7 @@ def wait(self) -> dict:
         async def go():
             await self._start()
             await self._macro("wait", 0.25)
-            st = await self._settled()
-            await self._frame()
-            return st
+            return await self._settled()
         d = self._describe(self._run(go()))
         d["text"] = "Waited 0.25 s. " + d["text"]
         return d
@@ -307,18 +412,23 @@ def _describe(self, st: dict) -> dict:
         parts.append(f"Gap in the ground: edge {gaps[0]['dx']} tiles ahead, {gaps[0]['width']} tiles wide." if gaps
                      else "No gap in the ground within 12 tiles.")
         walls = st.get("walls") or []
-        parts.append(f"Wall ahead: {walls[0]['kind']} {walls[0]['dx']} tiles ahead, {walls[0]['height']} tiles tall." if walls
-                     else "No pipe or wall within 8 tiles.")
+        if walls:
+            w = walls[0]
+            parts.append(f"Wall ahead: {w['kind']} {w['dx']} tiles ahead, {w['height']} tiles tall; "
+                         f"jump_right held {hold_for(w['height'])} clears it.")
+        else:
+            parts.append("No pipe or wall within 8 tiles.")
         # what one step reaches, and what is inside it: the fact the rule needs, stated rather
         # than left for the model to work out from a speed and a distance (it jumped one step late)
         # measured on the live game: at a run the distance to a walking enemy closes about 5.5
-        # tiles a step (11.5 -> 6 -> 1.3), a standing wall about 4; the hold, the model's answer
-        # and the enemy's own walk all fit in one step
+        # to 7.8 tiles a step (11.5 -> 6 -> 1.3; 9.8 -> 2), a standing wall about 4; the hold, the
+        # model's answer and the enemy's own walk all fit in one step, and an enemy 2 tiles away
+        # at a run is already too close to jump, so it is named a step earlier than it arrives
         reach = round(max(1.0, abs(st.get("xvel") or 0) * 60 * 0.6 / (8 * 4)), 1)
         closing = round(reach + 1.5, 1)
-        within = [f"the {en[0]['kind']} {en[0]['dx']} tiles ahead"] if en and en[0]["dx"] <= closing + 0.5 else []
-        within += [f"the gap {gaps[0]['dx']} tiles ahead"] if gaps and gaps[0]["dx"] <= reach + 0.5 else []
-        within += [f"the {walls[0]['kind']} {walls[0]['dx']} tiles ahead"] if walls and walls[0]["dx"] <= reach + 0.5 else []
+        within = [f"the {en[0]['kind']} {en[0]['dx']} tiles ahead"] if en and en[0]["dx"] <= closing + 2.5 else []
+        within += [f"the gap {gaps[0]['dx']} tiles ahead (hold long)"] if gaps and gaps[0]["dx"] <= reach + 0.5 else []
+        within += [f"the {walls[0]['kind']} {walls[0]['dx']} tiles ahead (hold {hold_for(walls[0]['height'])})"] if walls and walls[0]["dx"] <= reach + 0.5 else []
         parts.append(f"One step reaches about {reach} tiles, and a walking enemy closes about {closing}. "
                      + (f"Within one step: {'; '.join(within)}." if within else "Nothing is within one step."))
         parts.append(f"Lives {st.get('lives')}, time {st.get('time')}, score {st.get('score')}.")
@@ -326,7 +436,7 @@ def _describe(self, st: dict) -> dict:
         fields = {k: st.get(k) for k in ("x", "y", "on_ground", "dead", "xvel", "lives", "time", "score", "world")}
         fields["enemies"] = en
         fields["gaps"] = gaps
-        fields["walls"] = walls
+        fields["walls"] = [{**w, "hold": hold_for(w["height"])} for w in walls]
         fields["step_reach_tiles"] = reach
         fields["within_one_step"] = within
         return {"ok": True, "text": " ".join(parts), "fields": fields, "candidates": {}, "terminal": terminal}

From b037693a4282b709070a160d572e46057e7b743b Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sat, 19 Sep 2026 23:17:45 -0700
Subject: [PATCH 04/26] mario: the state names enemies behind and question
 blocks, and the environment times the jumps

Measured on the live game and written into the environment: an enemy walking at Mario is let
under a standing jump taken when it is a tile away (six of six between 0.8 and 1.2 tiles); a run
stops five tiles short of such an enemy, 3.5 short of a tall pipe (a jump with the run key held
from against it embeds Mario in its side, "falling" in place) and at a gap's edge; a question
block is hit by a jump started 1 to 1.5 tiles before it at a run; the hold an obstacle needs is
taken when the model's is shorter, and said. Heights are measured from where Mario stands, so
a stair step is one tile from the step below. Enemies behind Mario are in the state, since the
pair pacing behind the fourth pipe took a life on every back-off while "no enemy within 12 tiles
ahead" was true. The default goal asks for coins; the plugin is 0.2.0.

The page compares the package version it was built with against the launched harness and
relaunches it in place when they differ, so a kit updated in a new image reaches the harness
without a visit to Starter Kits. The stage is sized from the height budget so the column fits a
wide short window; the cards are shed below 1100px or 700px; the conversation column takes the
height under the bar instead of hanging its composer below the fold.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/README.md                  |  46 +++--
 kits/mario/app/src/lib/game.js        |  20 ++-
 kits/mario/app/src/lib/kit.js         |   2 +-
 kits/mario/app/src/styles/app.css     |  20 ++-
 kits/mario/kit.json                   |   2 +-
 kits/mario/plugin/plugin.json         |   2 +-
 kits/mario/plugin/server/mario_env.py | 234 +++++++++++++++++++++-----
 7 files changed, 258 insertions(+), 68 deletions(-)

diff --git a/kits/mario/README.md b/kits/mario/README.md
index bc114be..6800848 100644
--- a/kits/mario/README.md
+++ b/kits/mario/README.md
@@ -31,25 +31,39 @@ rate of frames it actually displayed.
 
 ### What is measured, not tuned
 
-The state is literal and the numbers in it come from the game. Two things were measured on the live
-game and are written into the environment rather than left to the model:
+The state is literal and the numbers in it come from the game: where Mario is, the nearest enemy
+ahead and whether it walks toward him, the nearest enemy behind him, the next gap, wall and
+question block with distances in tiles, and how far one step reaches. The things below were
+measured on the live game and written into the environment rather than left to the model:
 
 - **Jump heights.** Feet above the ground at the apex: a short hold reaches 3.1 tiles, a medium 3.9,
-  a long 4.1, standing or at a run. So the state says which hold clears the wall ahead: short for
-  2 tiles, medium for 3, long for 4.
+  a long 4.1, standing or at a run. So the state says which hold clears the wall ahead (short for
+  2 tiles, medium for 3, long for 4), and when the model's hold is shorter than what lies ahead
+  needs, the environment takes the needed one and says so in the result.
 - **When to leave the ground.** A decision lands every half second and a jump is a one-tile affair.
-  A wall 4 tiles tall is cleared by a long jump from 1.5 to 3 tiles back and from nowhere else:
-  from against it the apex is level with the top, and at a run from 4 tiles back the jump peaks
-  early and hits the side. A running jump covers about 9 tiles, so an enemy jumped from 4 tiles is
-  landed well past, and one jumped from 2 at a run is hit on take-off. The `jump_right` macro
-  therefore keeps running until the nearest thing ahead is at its distance, steps back first when
-  pressed against a tall wall, and waits for the landing when asked to jump mid-air. The model
-  decides to jump; the timing is the environment's, the way holding the keys is.
-
-On the model's own runs after these changes (Jev 1.13 through OpenRouter, 120 steps), all four
-pipes of the first level are cleared, three times in a row across restarts; before them a run
-stood against the first tall pipe for forty steps because the detector had dropped a pipe Mario
-overlapped by a tenth of a tile.
+  A wall 4 tiles tall is cleared by a long jump from 1.5 to 3 tiles back and from nowhere else; a
+  running jump covers about 9 tiles, so a gap is left from its edge at speed; a question block is
+  hit by a jump started 1 to 1.5 tiles before it at a run and missed from 2. So `jump_right` keeps
+  running until the nearest thing ahead is at its distance, steps back first when there is no room
+  for the run-up (and nothing behind), and waits for the landing when asked to jump mid-air.
+- **Enemies.** A running jump over the first Goomba hit the block row above it and dropped Mario
+  onto it, every life. An enemy walking toward Mario is instead let under a standing jump taken
+  when it is about one tile away (six of six tries between 0.8 and 1.2 tiles), and `run_right`
+  stops five tiles short of an enemy walking at him so that jump is taken standing. An enemy
+  below him, when he stands on a pipe, is waited out rather than jumped onto.
+
+The model decides to jump; the timing is the environment's, the way holding the keys is. Heights
+are measured from where Mario stands (his feet on the ground, the level he last stood on in the
+air), so a jump does not shrink the wall ahead and a stair step is one tile tall from the step
+below it.
+
+### Launching again after an update
+
+A launch captures the kit's package onto the harness. A kit updated afterwards (a new image)
+leaves the harness on the old package until something launches it again, so the page compares
+the package version it was built with against the harness and relaunches it in place when they
+differ. The base declares no built-in tools: its actions are the environment's, so the harness
+settings list none.
 
 ## Credits
 
diff --git a/kits/mario/app/src/lib/game.js b/kits/mario/app/src/lib/game.js
index 517bfe8..d53a40c 100644
--- a/kits/mario/app/src/lib/game.js
+++ b/kits/mario/app/src/lib/game.js
@@ -6,16 +6,30 @@
 //                  browser draws (the live workspace, so the file is read as it is written)
 //   its figures  = what the environment states at the end of every observation
 import {
-  cancelResponse, configureKit, kitConfig, kitHarness, sessionDetail, sessionTurns,
+  cancelResponse, configureKit, hr, kitConfig, kitHarness, sessionDetail, sessionTurns,
 } from 'reifyui/harness';
+import plugin from '../../../plugin/plugin.json';
 import { FRAME_FILE, KIT_ID } from './kit.js';
 
 configureKit({ kitId: KIT_ID });
 
 export { cancelResponse, sessionDetail, sessionTurns };
 
-/** The harness this kit launched, or null when it was never launched. */
-export const gameHarness = kitHarness;
+/** The harness this kit launched, or null when it was never launched.
+ *
+ *  A launch captures the kit's package onto the harness; a kit updated afterwards (a new image)
+ *  leaves the harness on the old package until something launches it again. The version the
+ *  page was built with is the kit's, so a harness holding another version is relaunched here,
+ *  which the launch route does in place: the same harness, the package replaced. */
+export async function gameHarness() {
+  const h = await kitHarness();
+  if (!h) return null;
+  const have = (h.plugins || []).find((p) => p.name === plugin.name)?.manifest?.version;
+  if (have === plugin.version) return h;
+  await hr(`/kits/${KIT_ID}/launch`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' });
+  configureKit({ kitId: KIT_ID });     // drops the cached harness
+  return kitHarness();
+}
 
 /** A run that has been opened but not started: no session exists until the first message. */
 export const PENDING = 'new';
diff --git a/kits/mario/app/src/lib/kit.js b/kits/mario/app/src/lib/kit.js
index 6996db7..5adf30c 100644
--- a/kits/mario/app/src/lib/kit.js
+++ b/kits/mario/app/src/lib/kit.js
@@ -14,4 +14,4 @@ export const CONSOLE_KITS = '/kits';
 export const FRAME_FILE = 'frame.jpg';
 
 /** The first message of a run when it is started with the Play button. */
-export const DEFAULT_GOAL = 'Play the level: keep running right, jump over enemies, gaps and pipes, and get as far as you can.';
+export const DEFAULT_GOAL = 'Play the level: keep running right, jump over enemies, gaps and pipes, hit the question blocks for coins, and get as far as you can.';
diff --git a/kits/mario/app/src/styles/app.css b/kits/mario/app/src/styles/app.css
index 7cb8029..0a6999c 100644
--- a/kits/mario/app/src/styles/app.css
+++ b/kits/mario/app/src/styles/app.css
@@ -9,6 +9,10 @@
 /* ── The page ─────────────────────────────────────────────────────────── */
 .mk-root { height: 100vh; display: flex; flex-direction: column; background: var(--bg); overflow: hidden; }
 .mk-body { flex: 1; min-height: 0; display: flex; }
+/* The conversation column is sized to the viewport by the shared stylesheet; here it sits under
+   the app bar, so it takes the height that is left, or its composer hangs below the fold. As a
+   drawer (narrow) the same height keeps its bottom on the window's bottom edge. */
+.mk-body > .uic-chat { height: calc(100vh - 56px); }
 .mk-main {
   flex: 1; min-width: 0; min-height: 0; display: flex; flex-direction: column; gap: 12px;
   padding: 18px 22px 16px; overflow: auto;
@@ -37,10 +41,13 @@
 
 /* ── The stage ────────────────────────────────────────────────────────── */
 .mk-stage-wrap { display: flex; flex-direction: column; gap: 10px; }
-/* Fills the column's width and keeps the game's shape; when the window is short it yields height
-   first and the picture letterboxes inside. */
+/* Keeps the game's shape and fits the window: the width is capped at what the height budget
+   allows once the bar, the credits and the row of cards are taken out, so on a wide short window
+   the whole column stays in view instead of the cards falling below the fold. */
 .mk-stage {
-  position: relative; width: 100%; aspect-ratio: 16 / 10; max-height: calc(100vh - 56px - 120px);
+  --mk-below: 250px;
+  position: relative; width: 100%; max-width: calc((100vh - 56px - var(--mk-below)) * 1.6);
+  margin: 0 auto; aspect-ratio: 16 / 10;
   min-height: 220px; background: #0B1020; border-radius: 16px; overflow: hidden;
   display: flex; align-items: center; justify-content: center;
   box-shadow: 0 30px 60px -32px rgba(15, 23, 42, .55), 0 0 0 1px rgba(15, 23, 42, .06);
@@ -90,10 +97,13 @@
   .uic-topbar .btn { padding: 0 9px; }
 }
 @container (max-width: 460px) { .uic-topbar .mk-model { display: none; } }
-@media (max-width: 1100px) { .mk-facts { grid-template-columns: 1fr; } }
+/* The cards are the first thing shed: below this width they would stack into a column that pushes
+   past the fold, and on a short window they would take the stage's room. */
+@media (max-width: 1100px), (max-height: 700px) { .mk-facts { display: none; } }
 @media (max-width: 900px) {
   .mk-main { padding: 12px 12px 12px; gap: 10px; }
-  .mk-stage { border-radius: 12px; max-height: calc(100vh - 56px - 96px); }
+  /* Narrow: the cards stack and the column scrolls; the stage takes the width it has. */
+  .mk-stage { border-radius: 12px; max-width: none; }
   .mk-hud { gap: 10px; padding: 18px 12px 10px; }
   .mk-stat span { display: none; }
 }
diff --git a/kits/mario/kit.json b/kits/mario/kit.json
index d5515b8..24d11a8 100644
--- a/kits/mario/kit.json
+++ b/kits/mario/kit.json
@@ -20,7 +20,7 @@
     ],
     "plugin": "plugin",
     "mcp_servers": [],
-    "system_prompt": "You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. Keep moving right. The state names any enemy, gap or wall that is within one step: jump over it now with jump_right, held as long as the state says. Otherwise run right. When Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left."
+    "system_prompt": "You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. Keep moving right. The state names any enemy, gap or wall that is within one step: jump over it now with jump_right, held as long as the state says. A question block overhead within one step pays a coin: jump_right under it. Otherwise run right. When Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left."
   },
   "app": {
     "dir": "app",
diff --git a/kits/mario/plugin/plugin.json b/kits/mario/plugin/plugin.json
index 7bceaab..0e019c6 100644
--- a/kits/mario/plugin/plugin.json
+++ b/kits/mario/plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "mario-env",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Full Screen Mario as an environment for the System One base: the game's state as literal text each step, the keys it listens to as actions, and the browser's frame for the page to show.",
   "homepage": "https://github.com/HarnessRouter/starter-kit",
   "license": "SEE LICENSE IN ../LICENSE.md"
diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index ee56619..0cbd520 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -37,8 +37,9 @@
                 "the ground, and what is ahead with distances in tiles. One step lasts about half a second and "
                 "covers up to 4 tiles at a run. Keep moving right. The state names any enemy, gap or wall that is "
                 "within one step: jump over it now, with jump_right, held as long as the state says (a taller "
-                "wall or a wider gap needs a longer hold). Otherwise run right. When Mario has just died, wait. "
-                "Finish when the level is cleared. Escalate when Mario has no lives left.")
+                "wall or a wider gap needs a longer hold). A question block overhead within one step pays a coin: "
+                "jump_right under it. Otherwise run right. When Mario has just died, wait. Finish when the level "
+                "is cleared. Escalate when Mario has no lives left.")
 # Measured on the live game, feet above the ground at the apex: a short hold reaches 3.1 tiles, a
 # medium 3.9, a long 4.1, standing or at a run. So a 2-tile pipe takes a short hold, a 3-tile one a
 # medium, and a 4-tile one a long hold with the run-up the jump_right macro provides (from against
@@ -53,15 +54,26 @@ def hold_for(height: float) -> str:
 
 STATE_JS = """(function(){
   if (!window.player || !window.gamescreen) return {ready: false};
+  // the world scrolls under a player who stays near the screen middle; counting the scroll gives
+  // a position in the level (progress the page can show, and the stuck check a real distance)
+  if (!window.__s1wrapped && typeof window.scrollWindow === 'function') {
+    var _sw = window.scrollWindow; window.__s1scroll = 0; window.__s1wrapped = true;
+    window.scrollWindow = function(x){ window.__s1scroll += (x || 0); return _sw.apply(this, arguments); };
+  }
   var u = window.unitsize || 4, T = 8 * u, p = player, sl = gamescreen.left, sr = gamescreen.right;
   function tiles(px){ return Math.round(px / T * 10) / 10; }
-  var enemies = [], gaps = [], walls = [];
-  var ground = (window.map && map.floor) ? map.floor * u : p.bottom;   // the ground under him, not his feet: heights must not shrink mid-jump
+  var enemies = [], behind = [], gaps = [], walls = [], blocks = [];
+  // heights are measured from where Mario stands: his feet on the ground, and in the air the
+  // level he last stood on, so a jump does not shrink the wall ahead and a stair step is one
+  // tile tall from the step below it, not four from the floor
+  if (p.resting) window.__s1ground = p.bottom;
+  var ground = p.resting ? p.bottom : (window.__s1ground || ((window.map && map.floor) ? map.floor * u : p.bottom));
   (window.characters || []).forEach(function(c){
     if (!c.alive || c === player || c.title === undefined) return;
     if (['Coin','Mushroom','FireFlower','Star','Vine','Text','Shell','Fireball'].indexOf(c.title) >= 0) return;
-    var dx = (c.left - p.right) / T, dy = (p.bottom - c.bottom) / T;
-    if (dx >= 0 && dx <= 12) enemies.push({kind: c.title, dx: Math.round(dx * 10) / 10, dy: Math.round(dy * 10) / 10});
+    var dx = (c.left - p.right) / T, dy = (p.bottom - c.bottom) / T, back = (p.left - c.right) / T;
+    if (dx >= 0 && dx <= 12) enemies.push({kind: c.title, dx: Math.round(dx * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) < 0 ? 'toward' : 'away'});
+    else if (back >= 0 && back <= 8) behind.push({kind: c.title, dx: Math.round(back * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) > 0 ? 'toward' : 'away'});
   });
   var floors = (window.solids || []).filter(function(s){ return s.alive && s.title === 'Floor' && s.top >= p.bottom - 4; });
   var x = p.right, gapStart = null;
@@ -70,7 +82,7 @@ def hold_for(height: float) -> str:
     if (!covered && gapStart === null) gapStart = i;
     if (covered && gapStart !== null) { gaps.push({dx: tiles(gapStart), width: tiles(i - gapStart)}); gapStart = null; }
   }
-  if (gapStart !== null) gaps.push({dx: tiles(gapStart), width: tiles(12 * T - gapStart)});
+  if (gapStart !== null && 12 * T - gapStart >= T / 2) gaps.push({dx: tiles(gapStart), width: tiles(12 * T - gapStart)});
   (window.solids || []).forEach(function(s){
     if (!s.alive || ['Pipe','Block','Brick','Stone'].indexOf(s.title) < 0) return;
     // anything whose far edge is still ahead of Mario counts, including the pipe he is pressed
@@ -82,15 +94,25 @@ def hold_for(height: float) -> str:
     var dx = Math.max(0, (s.left - p.right) / T);
     if (dx <= 8) walls.push({kind: s.title.toLowerCase(), dx: Math.round(dx * 10) / 10, height: tiles(ground - s.top)});
   });
-  enemies.sort(function(a, b){ return a.dx - b.dx; }); walls.sort(function(a, b){ return a.dx - b.dx; }); gaps.sort(function(a, b){ return a.dx - b.dx; });
+  enemies.sort(function(a, b){ return a.dx - b.dx; }); behind.sort(function(a, b){ return a.dx - b.dx; });
+  (window.solids || []).forEach(function(s){
+    // a question block still holding something, at the height a jump reaches (the head gets to
+    // about 4.9 tiles); it pays when hit from below
+    if (!s.alive || s.title !== 'Block' || s.used || s.hidden) return;
+    if (enemies.length && enemies[0].dx <= 10) return;
+    var up = (ground - s.bottom) / T, dx = (s.left - p.right) / T;
+    if (up < 3 || up > 4.5 || s.right <= p.left || dx > 8) return;
+    blocks.push({dx: Math.round(Math.max(-1, dx) * 10) / 10, up: Math.round(up * 10) / 10});
+  });
+  enemies.sort(function(a, b){ return a.dx - b.dx; }); walls.sort(function(a, b){ return a.dx - b.dx; }); gaps.sort(function(a, b){ return a.dx - b.dx; }); blocks.sort(function(a, b){ return a.dx - b.dx; });
   walls = walls.filter(function(w, i){ return i === 0 || w.dx !== walls[i - 1].dx || w.height !== walls[i - 1].height; });
   var d = window.data || {};
   function amt(k){ return d[k] && d[k].amount !== undefined ? d[k].amount : null; }
-  return {ready: true, x: tiles(p.left), y: tiles(ground - p.bottom),
+  return {ready: true, x: tiles(p.left), y: tiles(ground - p.bottom), level_x: tiles(p.left + (window.__s1scroll || 0)),
           dying: !!p.dying,
           screen_tiles: tiles(sr - sl), xvel: Math.round((p.xvel || 0) * 10) / 10, on_ground: !!p.resting, dead: !!p.dead,
-          power: p.power || 1, enemies: enemies.slice(0, 3), gaps: gaps.slice(0, 2), walls: walls.slice(0, 2),
-          lives: amt('lives'), time: amt('time'), score: amt('score'), world: amt('world'), paused: !!window.paused,
+          power: p.power || 1, enemies: enemies.slice(0, 3), behind: behind.slice(0, 2), gaps: gaps.slice(0, 2), walls: walls.slice(0, 2), blocks: blocks.slice(0, 2),
+          lives: amt('lives'), time: amt('time'), score: amt('score'), coins: amt('coins'), world: amt('world'), paused: !!window.paused,
           ending: !!(window.map && map.ending)};
 })()"""
 
@@ -136,6 +158,8 @@ def __init__(self):
         self.started_at = time.time()
         self.steps = 0
         self.frames = 0
+        self._stopped = 0          # consecutive runs that moved nothing
+        self._stopped_short = None # the enemy a run stopped short of, for the result text
         self._lives = None
         self._restarting_until = 0.0
         self._held: set[int] = set()
@@ -208,12 +232,40 @@ async def _macro(self, name: str, hold: float) -> None:
         if name == "run_right":
             await self._up(L)
             await self._down(R, S)
-            await asyncio.sleep(hold)
+            self._stopped_short = None
+            t0 = time.time()
+            while time.time() - t0 < hold:
+                await asyncio.sleep(0.03)
+                st = await self._eval(STATE_JS)
+                if not isinstance(st, dict) or not st.get("ready"):
+                    continue
+                en = self._approaching(st)
+                w = (st.get("walls") or [None])[0]
+                gap = (st.get("gaps") or [None])[0]
+                if en and en["dx"] <= 5.0 and en["dy"] > -1:
+                    # a run into an enemy walking at him ended in it every time (measured, nine
+                    # lives in one run); the run stops five tiles short, where the standing jump
+                    # that lets it under is taken from
+                    await self._up(R, S)
+                    self._stopped_short = {"kind": en["kind"] + " walking at him"}
+                    break
+                if w and w["height"] >= TALL and w["dx"] <= 3.5:
+                    # pressed against a tall pipe, a jump with the run key held rode up its side
+                    # and left Mario embedded in it, "falling" in place (measured); the run stops
+                    # where the jump's run-up starts
+                    await self._up(R, S)
+                    self._stopped_short = {"kind": f"{w['kind']} {w['height']} tiles tall"}
+                    break
+                if gap and gap["dx"] <= 1.2 and st.get("on_ground"):
+                    await self._up(R, S)
+                    self._stopped_short = {"kind": "gap"}
+                    break
         elif name == "jump_right":
             await self._up(L)
             await self._down(R, S)
             await self._land()
-            await self._approach()
+            if await self._approach():          # the jump was taken inside (an enemy let under)
+                return
             await self._eval(f"keydown({U}); 'ok'")
             await asyncio.sleep(hold)
             await self._eval(f"keyup({U}); 'ok'")
@@ -242,58 +294,126 @@ async def _land(self) -> None:
                 return
             await asyncio.sleep(0.03)
 
-    async def _approach(self) -> None:
+    def _needed_hold(self) -> str | None:
+        """The hold the nearest gap or wall within a step needs. A short hop into a gap and a
+        medium jump at a 4-tile pipe each cost a life (measured), so the environment takes the
+        hold the obstacle needs when the model's is shorter, and says so in the result."""
+        st = self._run(self._eval(STATE_JS), 10)
+        if not isinstance(st, dict) or not st.get("ready"):
+            return None
+        reach = max(1.0, abs(st.get("xvel") or 0) * 60 * 0.6 / (8 * 4))
+        gaps, walls = st.get("gaps") or [], st.get("walls") or []
+        if gaps and gaps[0]["dx"] <= reach + 0.5:
+            return "long"
+        if walls and walls[0]["dx"] <= reach + 0.5:
+            return hold_for(walls[0]["height"])
+        return None
+
+    async def _let_pass(self) -> bool:
+        """An enemy walking toward Mario is let under a standing jump: stop, wait until it is a
+        tile away, jump straight up, land, run on. Measured six times out of six between 0.8 and
+        1.2 tiles with a medium hold; a running jump over the first Goomba hit the block row above
+        it and dropped Mario onto it, every life. Returns whether the jump was taken here."""
+        R, S, U = KEY["right"], KEY["sprint"], KEY["jump"]
+        await self._up(R, S)
+        for _ in range(450):                    # up to 9 s of waiting: a Goomba twelve tiles off takes that long
+            await asyncio.sleep(0.02)
+            st = await self._eval(STATE_JS)
+            if not isinstance(st, dict) or not st.get("ready") or st.get("dying") or st.get("dead"):
+                await self._down(R, S)
+                return True
+            en = self._approaching(st)
+            if not en:
+                break                            # gone, or turned away: the running jump follows
+            if en["dy"] < -1:
+                continue                         # below him (he stands on something): it cannot reach him; let it pass or turn
+            if st.get("on_ground") and (en["dx"] <= 0.6 or (en["dx"] <= 1.0 and abs(st.get("xvel") or 0) < 0.6)):
+                await self._eval(f"keydown({U}); 'ok'")
+                await asyncio.sleep(HOLDS["medium"])
+                await self._eval(f"keyup({U}); 'ok'")
+                await asyncio.sleep(0.6)
+                await self._down(R, S)
+                return True
+        await self._down(R, S)
+        return False
+
+    async def _approach(self) -> bool:
         """The model decides to jump; when to leave the ground is the environment's, the way
         holding the keys is. A decision lands every half second or so and a jump is a one-tile
         affair, so a jump taken the moment it is chosen is early or late by luck. Measured on the
         live game: a wall 4 tiles tall is cleared by a long jump from 1.5 to 3 tiles back and from
         nowhere else (from against it the apex is level with the top; at a run from 4 back it
-        peaks early and hits the side); a running jump covers about 9 tiles, so an enemy jumped
-        from 4 tiles is landed well past, one jumped from 2 at a run is hit on take-off, and a gap
-        is best left from its edge. So: keep running until the nearest thing ahead is at its
-        distance, or, pressed against a tall wall with no speed, step back first."""
+        peaks early and hits the side); a running jump covers about 9 tiles, so a gap is best left
+        from its edge at speed; an enemy walking at Mario is let under a standing jump (see
+        _let_pass). So: an approaching enemy first; then keep running until the nearest thing
+        ahead is at its distance, backing off first when there is no room for the run-up."""
         st = await self._eval(STATE_JS)
         if not isinstance(st, dict) or not st.get("ready"):
-            return
+            return False
+        near = self._approaching(st)
+        if near and near["dx"] <= 6.5 and (near["dx"] >= 2.5 or abs(st.get("xvel") or 0) < 3):
+            if await self._let_pass():
+                return True
+            st = await self._eval(STATE_JS)              # the enemy is gone; what is ahead now
+            if not isinstance(st, dict) or not st.get("ready"):
+                return False
         target, want = self._target(st)
-        if target is None:
-            return
+        if target is None or not isinstance(want, (int, float)):
+            return False
         R, S, L = KEY["right"], KEY["sprint"], KEY["left"]
-        if target == "wall" and want is None:      # pressed against a tall wall, standing
+        dx = self._distance(st, target)
+        slow = abs(st.get("xvel") or 0) < 3
+        if slow and dx < want + 1.5 and st.get("on_ground"):
+            # no room for the run-up: step back first, unless something is there. A jump from
+            # 1.6 tiles back with no speed cleared the pipe and landed 2 tiles past it, on the
+            # enemies that pace there (measured: four lives in a row); three tiles of run-up
+            # give the jump its speed and the landing its distance
+            if any(b["dx"] <= 3.5 or (b.get("dir") == "toward" and b["dx"] <= 6) for b in st.get("behind") or []):
+                return False
             await self._up(R, S)
             await self._down(L)
-            for _ in range(40):
+            for _ in range(70):
                 await asyncio.sleep(0.03)
                 st = await self._eval(STATE_JS)
-                w = ((st or {}).get("walls") or [None])[0]
-                if not w or w["dx"] >= 1.6:
+                if not isinstance(st, dict) or st.get("dying") or st.get("dead"):
+                    break
+                if self._distance(st, target) >= want + 3.0:
                     break
             await self._up(L)
             await self._down(R, S)
             await asyncio.sleep(0.05)
-            return
-        for _ in range(34):                        # at most a second of running
+        for _ in range(40):                        # at most 1.2 s of running
             await asyncio.sleep(0.03)
             st = await self._eval(STATE_JS)
             if not isinstance(st, dict) or st.get("dying") or st.get("dead"):
-                return
-            t, w = self._target(st)
-            if t != target or w is None or self._distance(st, t) <= w:
-                return
+                return False
+            if self._distance(st, target) <= want:
+                return False
+        return False
 
     @staticmethod
     def _distance(st: dict, kind: str) -> float:
-        rows = st.get({"enemy": "enemies", "wall": "walls", "gap": "gaps"}[kind]) or []
+        rows = st.get({"enemy": "enemies", "wall": "walls", "gap": "gaps", "block": "blocks"}[kind]) or []
         return rows[0]["dx"] if rows else 99.0
 
+    @staticmethod
+    def _approaching(st: dict):
+        """The nearest enemy walking at Mario from either side, within reach of mattering."""
+        en, back = st.get("enemies") or [], st.get("behind") or []
+        near = [e for e in en if e.get("dir") == "toward" and e["dx"] <= 12 and e["dy"] < 1]
+        near += [e for e in back if e.get("dir") == "toward" and e["dx"] <= 6 and e["dy"] < 1]
+        return min(near, key=lambda e: e["dx"]) if near else None
+
     @staticmethod
     def _target(st: dict):
         """What the jump is for and the distance to leave the ground at: (kind, tiles), with
-        None tiles meaning jump now, and ("wall", None) meaning pressed against a tall wall."""
+        None tiles meaning jump now."""
         near = []
-        en, walls, gaps = st.get("enemies") or [], st.get("walls") or [], st.get("gaps") or []
+        en, walls, gaps, blocks = st.get("enemies") or [], st.get("walls") or [], st.get("gaps") or [], st.get("blocks") or []
         if en and en[0]["dx"] <= 10:
             near.append((en[0]["dx"], "enemy"))
+        if blocks and blocks[0]["dx"] <= 6:
+            near.append((blocks[0]["dx"], "block"))
         if walls and walls[0]["dx"] <= 6:
             near.append((walls[0]["dx"], "wall"))
         if gaps and gaps[0]["dx"] <= 6:
@@ -305,12 +425,15 @@ def _target(st: dict):
         if kind == "wall":
             if walls[0]["height"] < TALL:
                 return None, None                       # any distance within a step clears it
-            if dx < 1.4 and not fast and st.get("on_ground"):
-                return "wall", None
             return "wall", 2.8
         if kind == "enemy":
             return ("enemy", 4.0) if fast and dx > 4.0 else (None, None)
-        return ("gap", 1.5) if dx > 1.5 else (None, None)
+        if kind == "block":
+            # measured: at a run a medium jump started 1 to 1.5 tiles before the block hits it,
+            # from 2 tiles or more it peaks short of it
+            want = 1.3 if fast else 0.5
+            return ("block", want) if dx > want else (None, None)
+        return "gap", 1.5
 
     # ── the tools ──
     def reset(self, goal: str) -> dict:
@@ -356,6 +479,7 @@ def _restarting(self, st: dict) -> bool:
         lives = st.get("lives")
         if self._lives is not None and lives is not None and lives < self._lives:
             self._restarting_until = time.time() + 4.0
+            self._loop.call_soon_threadsafe(lambda: self._loop.create_task(self._eval("window.__s1scroll = 0; 'ok'")))
         if lives is not None:
             self._lives = lives
         if st.get("dead") or st.get("dying"):
@@ -364,6 +488,10 @@ def _restarting(self, st: dict) -> bool:
 
     def act(self, name: str, hold: str) -> dict:
         seconds = HOLDS.get(hold, HOLDS["medium"])
+        needed = self._needed_hold() if name == "jump_right" else None
+        taken = needed if needed and HOLDS[needed] > seconds else None
+        if taken:
+            seconds = HOLDS[taken]
 
         async def go():
             await self._start()
@@ -372,8 +500,16 @@ async def go():
             return await self._settled()
         st = self._run(go())
         self.steps += 1
+        if name in ("run_right", "jump_right") and st.get("on_ground") and abs(st.get("xvel") or 0) < 0.5 and not st.get("dying"):
+            self._stopped += 1
+        else:
+            self._stopped = 0
         d = self._describe(st)
-        d["text"] = f"{name} held {seconds:.2f} s. " + d["text"]
+        if name == "walk_left":
+            self._stopped = 0
+        short = self._stopped_short if name == "run_right" else None
+        d["text"] = (f"{name} held {seconds:.2f} s" + (f" ({taken}: what lay ahead needed it)" if taken else "")
+                     + (f", stopped short of the {short['kind']}" if short else "") + ". " + d["text"])
         return d
 
     def wait(self) -> dict:
@@ -405,9 +541,14 @@ def _describe(self, st: dict) -> dict:
         if en:
             e = en[0]
             where = "at Mario's height" if abs(e["dy"]) < 1 else ("above" if e["dy"] > 0 else "below")
-            parts.append(f"Nearest enemy: {e['kind']} {e['dx']} tiles ahead, {where}." + (f" {len(en) - 1} more behind it." if len(en) > 1 else ""))
+            parts.append(f"Nearest enemy: {e['kind']} {e['dx']} tiles ahead, {where}, walking {'toward Mario' if e.get('dir') == 'toward' else 'away'}."
+                         + (f" {len(en) - 1} more behind it." if len(en) > 1 else ""))
         else:
             parts.append("No enemy within 12 tiles ahead.")
+        back = st.get("behind") or []
+        if back:
+            b = back[0]
+            parts.append(f"Behind Mario: {b['kind']} {b['dx']} tiles back, walking {'toward him' if b.get('dir') == 'toward' else 'away'}.")
         gaps = st.get("gaps") or []
         parts.append(f"Gap in the ground: edge {gaps[0]['dx']} tiles ahead, {gaps[0]['width']} tiles wide." if gaps
                      else "No gap in the ground within 12 tiles.")
@@ -418,6 +559,10 @@ def _describe(self, st: dict) -> dict:
                          f"jump_right held {hold_for(w['height'])} clears it.")
         else:
             parts.append("No pipe or wall within 8 tiles.")
+        blocks = st.get("blocks") or []
+        if blocks:
+            b = blocks[0]
+            parts.append(f"Question block overhead: {b['dx']} tiles ahead, {b['up']} tiles up; jump_right under it pays a coin.")
         # what one step reaches, and what is inside it: the fact the rule needs, stated rather
         # than left for the model to work out from a speed and a distance (it jumped one step late)
         # measured on the live game: at a run the distance to a walking enemy closes about 5.5
@@ -429,14 +574,21 @@ def _describe(self, st: dict) -> dict:
         within = [f"the {en[0]['kind']} {en[0]['dx']} tiles ahead"] if en and en[0]["dx"] <= closing + 2.5 else []
         within += [f"the gap {gaps[0]['dx']} tiles ahead (hold long)"] if gaps and gaps[0]["dx"] <= reach + 0.5 else []
         within += [f"the {walls[0]['kind']} {walls[0]['dx']} tiles ahead (hold {hold_for(walls[0]['height'])})"] if walls and walls[0]["dx"] <= reach + 0.5 else []
+        within += [f"the question block {blocks[0]['dx']} tiles ahead (hold medium)"] if blocks and blocks[0]["dx"] <= reach + 0.5 else []
         parts.append(f"One step reaches about {reach} tiles, and a walking enemy closes about {closing}. "
                      + (f"Within one step: {'; '.join(within)}." if within else "Nothing is within one step."))
-        parts.append(f"Lives {st.get('lives')}, time {st.get('time')}, score {st.get('score')}.")
+        if self._stopped >= 2:
+            parts.append(f"Mario has been stopped in place for {self._stopped} steps by something he is pressed "
+                         "against: walk_left one step, then jump_right held long.")
+        parts.append(f"Lives {st.get('lives')}, coins {st.get('coins')}, time {st.get('time')}, score {st.get('score')}.")
         terminal = bool(st.get("ending")) or (bool(st.get("dead")) and (st.get("lives") or 0) <= 0)
-        fields = {k: st.get(k) for k in ("x", "y", "on_ground", "dead", "xvel", "lives", "time", "score", "world")}
+        fields = {k: st.get(k) for k in ("x", "y", "level_x", "on_ground", "dead", "xvel", "lives", "coins", "time", "score", "world")}
         fields["enemies"] = en
+        fields["behind"] = st.get("behind") or []
         fields["gaps"] = gaps
         fields["walls"] = [{**w, "hold": hold_for(w["height"])} for w in walls]
+        fields["blocks"] = blocks
+        fields["stopped_steps"] = self._stopped
         fields["step_reach_tiles"] = reach
         fields["within_one_step"] = within
         return {"ok": True, "text": " ".join(parts), "fields": fields, "candidates": {}, "terminal": terminal}

From 0a6502b8db0baa2110c4ad371b3ab0040847dd0d Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 00:15:40 -0700
Subject: [PATCH 05/26] mario: the fourth pipe is cleared, and Mario is never
 left inside one

Measured through the environment's own jump from against the fourth pipe: the back-off stops
against the third pipe five tiles back, and overlapping its far edge by a tenth of a tile made
the detector report it as a wall "0 tiles ahead", so the run-up jumped at once, 4.5 tiles early,
with the apex 2.5 tiles short of the pipe. A wall whose far edge is at Mario's back now counts as
behind him (a quarter tile of tolerance), the take-off is at 2.4 tiles, and the sampled jump
crosses the pipe's top and lands on the far side.

Held into a pipe's side in the air, Mario "falls" in place at terminal speed for as long as a key
is held, and a let-under jump taken from against the pipe followed by the run key mid-air put
him there every life. The let-under steps off the wall first and takes the run key back on the
ground; after every action, and in the landing wait, a Mario held that way has every key let go,
which drops him to the ground within a second (measured). The let-under wait is bounded (3.5 s,
5 s under a block row) and used for an enemy about to arrive or one under blocks; a farther one
in the open is jumped at a run. A run stops three tiles short of a tall pipe and at a gap's edge
as it stops short of an enemy.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 95 ++++++++++++++++++++++-----
 1 file changed, 80 insertions(+), 15 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 0cbd520..3dc84a9 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -62,7 +62,7 @@ def hold_for(height: float) -> str:
   }
   var u = window.unitsize || 4, T = 8 * u, p = player, sl = gamescreen.left, sr = gamescreen.right;
   function tiles(px){ return Math.round(px / T * 10) / 10; }
-  var enemies = [], behind = [], gaps = [], walls = [], blocks = [];
+  var enemies = [], behind = [], gaps = [], walls = [], blocks = [], overhead = [];
   // heights are measured from where Mario stands: his feet on the ground, and in the air the
   // level he last stood on, so a jump does not shrink the wall ahead and a stair step is one
   // tile tall from the step below it, not four from the floor
@@ -90,7 +90,10 @@ def hold_for(height: float) -> str:
     // forty steps of "no wall within 8 tiles" against a pipe). A wall stands on the ground: what
     // sits at or below the ground is floor, and what floats a tile or more above it (the block
     // rows) is run under, not jumped
-    if (s.right <= p.left || s.top >= ground - 2 || s.bottom < ground - T) return;
+    // behind him with a quarter tile of tolerance: pressed against a pipe's far side he overlaps
+    // it by a tenth of a tile, and counted as "0 tiles ahead" it made the run-up jump at once,
+    // 4.5 tiles early, into the side of the pipe that was actually ahead (measured)
+    if (s.right <= p.left + T / 4 || s.top >= ground - 2 || s.bottom < ground - T) return;
     var dx = Math.max(0, (s.left - p.right) / T);
     if (dx <= 8) walls.push({kind: s.title.toLowerCase(), dx: Math.round(dx * 10) / 10, height: tiles(ground - s.top)});
   });
@@ -98,10 +101,12 @@ def hold_for(height: float) -> str:
   (window.solids || []).forEach(function(s){
     // a question block still holding something, at the height a jump reaches (the head gets to
     // about 4.9 tiles); it pays when hit from below
-    if (!s.alive || s.title !== 'Block' || s.used || s.hidden) return;
-    if (enemies.length && enemies[0].dx <= 10) return;
+    if (!s.alive || (s.title !== 'Block' && s.title !== 'Brick') || s.hidden) return;
     var up = (ground - s.bottom) / T, dx = (s.left - p.right) / T;
     if (up < 3 || up > 4.5 || s.right <= p.left || dx > 8) return;
+    overhead.push({dx: Math.round(Math.max(-1, dx) * 10) / 10});
+    if (s.title !== 'Block' || s.used) return;
+    if (enemies.length && enemies[0].dx <= 10) return;
     blocks.push({dx: Math.round(Math.max(-1, dx) * 10) / 10, up: Math.round(up * 10) / 10});
   });
   enemies.sort(function(a, b){ return a.dx - b.dx; }); walls.sort(function(a, b){ return a.dx - b.dx; }); gaps.sort(function(a, b){ return a.dx - b.dx; }); blocks.sort(function(a, b){ return a.dx - b.dx; });
@@ -111,7 +116,7 @@ def hold_for(height: float) -> str:
   return {ready: true, x: tiles(p.left), y: tiles(ground - p.bottom), level_x: tiles(p.left + (window.__s1scroll || 0)),
           dying: !!p.dying,
           screen_tiles: tiles(sr - sl), xvel: Math.round((p.xvel || 0) * 10) / 10, on_ground: !!p.resting, dead: !!p.dead,
-          power: p.power || 1, enemies: enemies.slice(0, 3), behind: behind.slice(0, 2), gaps: gaps.slice(0, 2), walls: walls.slice(0, 2), blocks: blocks.slice(0, 2),
+          power: p.power || 1, enemies: enemies.slice(0, 3), behind: behind.slice(0, 2), gaps: gaps.slice(0, 2), walls: walls.slice(0, 2), blocks: blocks.slice(0, 2), overhead: overhead.slice(0, 4),
           lives: amt('lives'), time: amt('time'), score: amt('score'), coins: amt('coins'), world: amt('world'), paused: !!window.paused,
           ending: !!(window.map && map.ending)};
 })()"""
@@ -249,7 +254,7 @@ async def _macro(self, name: str, hold: float) -> None:
                     await self._up(R, S)
                     self._stopped_short = {"kind": en["kind"] + " walking at him"}
                     break
-                if w and w["height"] >= TALL and w["dx"] <= 3.5:
+                if w and w["height"] >= TALL and w["dx"] <= 3.0:
                     # pressed against a tall pipe, a jump with the run key held rode up its side
                     # and left Mario embedded in it, "falling" in place (measured); the run stops
                     # where the jump's run-up starts
@@ -264,6 +269,7 @@ async def _macro(self, name: str, hold: float) -> None:
             await self._up(L)
             await self._down(R, S)
             await self._land()
+            await self._peel()
             if await self._approach():          # the jump was taken inside (an enemy let under)
                 return
             await self._eval(f"keydown({U}); 'ok'")
@@ -288,12 +294,49 @@ async def _macro(self, name: str, hold: float) -> None:
 
     async def _land(self) -> None:
         """A jump key pressed in the air does nothing in this game, so a jump asked for mid-flight
-        is taken on landing: the action means what it says instead of being spent."""
-        for _ in range(30):
+        is taken on landing: the action means what it says instead of being spent. Mario held
+        against a pipe's side mid-air, "falling" in place at terminal speed (measured: yvel 7, no
+        movement, for seven decisions), is freed by letting go of the run key and stepping left."""
+        for i in range(30):
             if await self._eval("!!player.resting || !!player.dead || !!player.dying"):
                 return
+            if i == 12:
+                await self._unstick()
             await asyncio.sleep(0.03)
 
+    async def _unstick(self) -> None:
+        """Held into a pipe's side in the air, Mario "falls" in place at terminal speed for as long
+        as a key is held (measured: yvel 7, no movement, a whole life against the fourth pipe).
+        Letting go of every key drops him to the ground within a second (measured); the run key
+        comes back once he is down."""
+        if not await self._eval("!player.resting && !player.dead && !player.dying && player.yvel >= 6.9"):
+            return
+        y0 = await self._eval("player.bottom")
+        await asyncio.sleep(0.12)
+        if await self._eval("player.bottom") != y0:
+            return
+        held = set(self._held)
+        await self._up(*held)
+        for _ in range(40):
+            await asyncio.sleep(0.03)
+            if await self._eval("!!player.resting || !!player.dead || !!player.dying"):
+                break
+        if KEY["right"] in held:
+            await self._down(KEY["right"], KEY["sprint"])
+
+    async def _peel(self) -> None:
+        """Overlapping a wall's edge (he stops a tenth of a tile inside it), a jump with the run key
+        held rides up its side and embeds him. A short step back first, and the jump is a jump."""
+        st = await self._eval(STATE_JS)
+        w = ((st or {}).get("walls") or [None])[0] if isinstance(st, dict) else None
+        if w and w["dx"] <= 0.05 and st.get("on_ground"):
+            await self._up(KEY["right"], KEY["sprint"])
+            await self._down(KEY["left"])
+            await asyncio.sleep(0.12)
+            await self._up(KEY["left"])
+            await asyncio.sleep(0.1)
+            await self._down(KEY["right"], KEY["sprint"])
+
     def _needed_hold(self) -> str | None:
         """The hold the nearest gap or wall within a step needs. A short hop into a gap and a
         medium jump at a 4-tile pipe each cost a life (measured), so the environment takes the
@@ -309,14 +352,14 @@ def _needed_hold(self) -> str | None:
             return hold_for(walls[0]["height"])
         return None
 
-    async def _let_pass(self) -> bool:
+    async def _let_pass(self, seconds: float = 3.5) -> bool:
         """An enemy walking toward Mario is let under a standing jump: stop, wait until it is a
         tile away, jump straight up, land, run on. Measured six times out of six between 0.8 and
         1.2 tiles with a medium hold; a running jump over the first Goomba hit the block row above
         it and dropped Mario onto it, every life. Returns whether the jump was taken here."""
         R, S, U = KEY["right"], KEY["sprint"], KEY["jump"]
         await self._up(R, S)
-        for _ in range(450):                    # up to 9 s of waiting: a Goomba twelve tiles off takes that long
+        for _ in range(int(seconds / 0.02)):
             await asyncio.sleep(0.02)
             st = await self._eval(STATE_JS)
             if not isinstance(st, dict) or not st.get("ready") or st.get("dying") or st.get("dead"):
@@ -328,10 +371,20 @@ async def _let_pass(self) -> bool:
             if en["dy"] < -1:
                 continue                         # below him (he stands on something): it cannot reach him; let it pass or turn
             if st.get("on_ground") and (en["dx"] <= 0.6 or (en["dx"] <= 1.0 and abs(st.get("xvel") or 0) < 0.6)):
+                w = (st.get("walls") or [None])[0]
+                if w and w["dx"] <= 0.05:
+                    # against a pipe, a jump here followed by the run key mid-air rode up its side
+                    # and embedded him (measured: every life at the fourth pipe); a step back first
+                    await self._down(KEY["left"])
+                    await asyncio.sleep(0.12)
+                    await self._up(KEY["left"])
                 await self._eval(f"keydown({U}); 'ok'")
                 await asyncio.sleep(HOLDS["medium"])
                 await self._eval(f"keyup({U}); 'ok'")
-                await asyncio.sleep(0.6)
+                for _ in range(40):                  # the run key comes back on the ground, never against a wall in the air
+                    await asyncio.sleep(0.03)
+                    if await self._eval("!!player.resting || !!player.dead || !!player.dying"):
+                        break
                 await self._down(R, S)
                 return True
         await self._down(R, S)
@@ -351,8 +404,12 @@ async def _approach(self) -> bool:
         if not isinstance(st, dict) or not st.get("ready"):
             return False
         near = self._approaching(st)
-        if near and near["dx"] <= 6.5 and (near["dx"] >= 2.5 or abs(st.get("xvel") or 0) < 3):
-            if await self._let_pass():
+        slow_now = abs(st.get("xvel") or 0) < 3
+        # the standing jump that lets an enemy under is for one about to arrive, or for one under a
+        # block row (where a running jump hits the blocks and drops onto it); a farther one in the
+        # open is jumped at a run from four tiles, which lands well past it
+        if near and near["dx"] <= 6.5 and (near["dx"] <= 3.0 or slow_now or self._blocks_overhead(st)):
+            if await self._let_pass(5.0 if self._blocks_overhead(st) else 3.5):
                 return True
             st = await self._eval(STATE_JS)              # the enemy is gone; what is ahead now
             if not isinstance(st, dict) or not st.get("ready"):
@@ -396,6 +453,12 @@ def _distance(st: dict, kind: str) -> float:
         rows = st.get({"enemy": "enemies", "wall": "walls", "gap": "gaps", "block": "blocks"}[kind]) or []
         return rows[0]["dx"] if rows else 99.0
 
+    @staticmethod
+    def _blocks_overhead(st: dict) -> bool:
+        """A block row within a running jump's flight: the state drops question blocks near an
+        enemy, so the fields carry the row for this purpose."""
+        return any(b["dx"] <= 6 for b in st.get("overhead") or [])
+
     @staticmethod
     def _approaching(st: dict):
         """The nearest enemy walking at Mario from either side, within reach of mattering."""
@@ -425,7 +488,7 @@ def _target(st: dict):
         if kind == "wall":
             if walls[0]["height"] < TALL:
                 return None, None                       # any distance within a step clears it
-            return "wall", 2.8
+            return "wall", 2.4
         if kind == "enemy":
             return ("enemy", 4.0) if fast and dx > 4.0 else (None, None)
         if kind == "block":
@@ -464,7 +527,9 @@ async def go():
 
     async def _settled(self) -> dict:
         """The state once the level is back after a death: while it restarts the clock is frozen and
-        the floors are gone (the gap that is not there); an action during that window is spent."""
+        the floors are gone (the gap that is not there); an action during that window is spent.
+        And never a state held inside a pipe's side: see _unstick."""
+        await self._unstick()
         st = await self._eval(STATE_JS)
         if isinstance(st, dict) and self._restarting(st):
             await self._up(*list(self._held))

From ededfc6c32d4d688f0b920ad3e3cba1124616d07 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 00:16:35 -0700
Subject: [PATCH 06/26] mario: a question block Mario stands under is 'right
 overhead', never a negative distance

The state said 'Question block overhead: -1 tiles ahead' once Mario was under one, and the
model's confidence fell below the gate on that sentence four actions into a run (measured on the
test box: stopped, no confident action). The distance is clamped at zero and said in words.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 3dc84a9..7ee3fef 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -107,7 +107,7 @@ def hold_for(height: float) -> str:
     overhead.push({dx: Math.round(Math.max(-1, dx) * 10) / 10});
     if (s.title !== 'Block' || s.used) return;
     if (enemies.length && enemies[0].dx <= 10) return;
-    blocks.push({dx: Math.round(Math.max(-1, dx) * 10) / 10, up: Math.round(up * 10) / 10});
+    blocks.push({dx: Math.round(Math.max(0, dx) * 10) / 10, up: Math.round(up * 10) / 10});
   });
   enemies.sort(function(a, b){ return a.dx - b.dx; }); walls.sort(function(a, b){ return a.dx - b.dx; }); gaps.sort(function(a, b){ return a.dx - b.dx; }); blocks.sort(function(a, b){ return a.dx - b.dx; });
   walls = walls.filter(function(w, i){ return i === 0 || w.dx !== walls[i - 1].dx || w.height !== walls[i - 1].height; });
@@ -627,7 +627,8 @@ def _describe(self, st: dict) -> dict:
         blocks = st.get("blocks") or []
         if blocks:
             b = blocks[0]
-            parts.append(f"Question block overhead: {b['dx']} tiles ahead, {b['up']} tiles up; jump_right under it pays a coin.")
+            where = "right overhead" if b["dx"] <= 0 else f"{b['dx']} tiles ahead"
+            parts.append(f"Question block {where}, {b['up']} tiles up; jump_right under it pays a coin.")
         # what one step reaches, and what is inside it: the fact the rule needs, stated rather
         # than left for the model to work out from a speed and a distance (it jumped one step late)
         # measured on the live game: at a run the distance to a walking enemy closes about 5.5

From df36b4feeeae8ca7142692cb06ddc99f98a90cb5 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 00:20:07 -0700
Subject: [PATCH 07/26] mario: the README says where the runs stand

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/README.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/kits/mario/README.md b/kits/mario/README.md
index 6800848..d02799f 100644
--- a/kits/mario/README.md
+++ b/kits/mario/README.md
@@ -57,6 +57,15 @@ are measured from where Mario stands (his feet on the ground, the level he last
 air), so a jump does not shrink the wall ahead and a stair step is one tile tall from the step
 below it.
 
+On the model's own runs after these changes (Jev 1.13 through OpenRouter, 400 steps): all four
+pipes of the first level are cleared, the question blocks pay (10 coins and a score of 17,300 in
+one 119-action run), the run moves at about two seconds an action, and the furthest point reached
+is about half the level. The level is not won yet: the lives go to the Goomba pair pacing around
+the third and fourth pipes, to the landing beyond the 3-tile gap where a Goomba waits, and to a
+pair near the middle of the level. Each of those is a state question, not a model question, and
+each earlier death class was removed the same way: read the trace, measure the game, write the
+fact into the environment.
+
 ### Launching again after an update
 
 A launch captures the kit's package onto the harness. A kit updated afterwards (a new image)

From 20810b068127cf53cd4e516a02fb6799317e7743 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 00:39:39 -0700
Subject: [PATCH 08/26] mario: New run starts over

A run rewrites the URL to its own id without a navigation, so setting the hash back to the start
changed nothing the router could see and the page kept its state (measured: New run after a
finished run did nothing). The app now remounts the page outright and puts the URL back.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/app/src/App.jsx            | 12 +++++++++---
 kits/mario/app/src/pages/GamePage.jsx |  6 +-----
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/kits/mario/app/src/App.jsx b/kits/mario/app/src/App.jsx
index aaa42e7..22c3623 100644
--- a/kits/mario/app/src/App.jsx
+++ b/kits/mario/app/src/App.jsx
@@ -16,11 +16,17 @@ function parseHash() {
 }
 
 export default function App() {
-  const [route, setRoute] = useState(parseHash);
+  const [route, setRoute] = useState(() => ({ ...parseHash(), seq: 0 }));
   useEffect(() => {
-    const onHash = () => setRoute(parseHash());
+    const onHash = () => setRoute((r) => ({ ...parseHash(), seq: r.seq }));
     window.addEventListener('hashchange', onHash);
     return () => window.removeEventListener('hashchange', onHash);
   }, []);
-  return <DialogHost><GamePage key={route.id} id={route.id} /></DialogHost>;
+  // A run rewrites the URL to its own id without a navigation, so "New run" cannot rely on a hash
+  // change to start over: the page is remounted outright, and the URL put back to the start.
+  const newRun = () => {
+    window.history.replaceState(null, '', `${window.location.pathname}#/`);
+    setRoute((r) => ({ id: PENDING, seq: r.seq + 1 }));
+  };
+  return <DialogHost><GamePage key={`${route.id}:${route.seq}`} id={route.id} onNewRun={newRun} /></DialogHost>;
 }
diff --git a/kits/mario/app/src/pages/GamePage.jsx b/kits/mario/app/src/pages/GamePage.jsx
index 1392314..3c2948d 100644
--- a/kits/mario/app/src/pages/GamePage.jsx
+++ b/kits/mario/app/src/pages/GamePage.jsx
@@ -32,7 +32,7 @@ function count(stats, ev) {
   }
 }
 
-export function GamePage({ id: routeId }) {
+export function GamePage({ id: routeId, onNewRun }) {
   // The session id lives in state, not in the route: a run starts pending and becomes a session
   // when its first turn opens one, which arrives while the stream is open.
   const [id, setId] = useState(routeId);
@@ -84,10 +84,6 @@ export function GamePage({ id: routeId }) {
   }), []);
 
   const onStop = useCallback(() => { if (rid) cancelResponse(rid).catch(() => {}); }, [rid]);
-  const onNewRun = useCallback(() => {
-    window.location.hash = '#/';
-    if (isPending(id)) { setStatus(''); setRid(''); dispatch({ type: 'end' }); }
-  }, [id]);
 
   return (
     <div className="mk-root">

From 328fdbd180b3242b4d5fc93126a5e6c1919040bb Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 00:58:31 -0700
Subject: [PATCH 09/26] mario: what the recordings showed

Every attempt is now recorded (each screencast frame, timestamped) and every death becomes a
contact sheet of the seconds before it; these changes come from those sheets, not from the
trace text. An enemy met without speed is never jumped at (a jump from a standstill landed on
it): one walking at Mario is let under, one walking away is waited for, since the pair turns at
the next pipe. On a pipe's top nothing reaches him, so he waits for the pair below to be walking
away before stepping off slowly. Beyond a gap the landing zone is waited clear for up to eight
seconds, since the pair there walks into the gap. An enemy above is neither a target nor waited
under: it drops off its ledge onto him. A run has no hold to judge: the model was sure of the
run and unsure of its length, and the gate refused the weaker answer three times, ending a run
with lives left. Enemies behind him are outrun, or let under when one is on him at a wall.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 125 ++++++++++++++++++++++----
 1 file changed, 108 insertions(+), 17 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 7ee3fef..9c5e13d 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -80,7 +80,7 @@ def hold_for(height: float) -> str:
   for (var i = 0; i <= 12 * T; i += T / 4) {
     var covered = floors.some(function(f){ return f.left <= x + i && x + i <= f.right; });
     if (!covered && gapStart === null) gapStart = i;
-    if (covered && gapStart !== null) { gaps.push({dx: tiles(gapStart), width: tiles(i - gapStart)}); gapStart = null; }
+    if (covered && gapStart !== null) { if (i - gapStart >= T / 2) gaps.push({dx: tiles(gapStart), width: tiles(i - gapStart)}); gapStart = null; }
   }
   if (gapStart !== null && 12 * T - gapStart >= T / 2) gaps.push({dx: tiles(gapStart), width: tiles(12 * T - gapStart)});
   (window.solids || []).forEach(function(s){
@@ -165,6 +165,8 @@ def __init__(self):
         self.frames = 0
         self._stopped = 0          # consecutive runs that moved nothing
         self._stopped_short = None # the enemy a run stopped short of, for the result text
+        self._walked_off = False   # a jump asked for on a pipe's top that became a step off it
+        self._waited = False       # a jump asked for beside an enemy walking away that became a wait
         self._lives = None
         self._restarting_until = 0.0
         self._held: set[int] = set()
@@ -247,12 +249,24 @@ async def _macro(self, name: str, hold: float) -> None:
                 en = self._approaching(st)
                 w = (st.get("walls") or [None])[0]
                 gap = (st.get("gaps") or [None])[0]
-                if en and en["dx"] <= 5.0 and en["dy"] > -1:
+                if en and en.get("side") == "behind":
+                    # one at his back is outrun; one already on him, with a wall ahead, is let under
+                    if en["dx"] <= 1.2 and w and w["dx"] <= 1.0:
+                        await self._up(R, S)
+                        await self._let_pass(2.0)
+                        self._stopped_short = {"kind": en["kind"] + " at his back, let under a jump"}
+                        break
+                    en = None
+                if en and en["dx"] <= 5.0 and abs(en["dy"]) < 1:
                     # a run into an enemy walking at him ended in it every time (measured, nine
                     # lives in one run); the run stops five tiles short, where the standing jump
-                    # that lets it under is taken from
+                    # that lets it under is taken from. One already within two tiles is let under
+                    # here and now: a decision later is a decision too late (measured at x 106)
                     await self._up(R, S)
                     self._stopped_short = {"kind": en["kind"] + " walking at him"}
+                    if en["dx"] <= 2.5:
+                        await self._let_pass(2.5)
+                        self._stopped_short = {"kind": en["kind"] + " walking at him, let under a jump"}
                     break
                 if w and w["height"] >= TALL and w["dx"] <= 3.0:
                     # pressed against a tall pipe, a jump with the run key held rode up its side
@@ -352,6 +366,23 @@ def _needed_hold(self) -> str | None:
             return hold_for(walls[0]["height"])
         return None
 
+    async def _wait_enemy(self) -> bool:
+        R, S = KEY["right"], KEY["sprint"]
+        await self._up(R, S)
+        for _ in range(60):                                      # up to 6 s
+            st = await self._eval(STATE_JS)
+            if not isinstance(st, dict) or not st.get("ready") or st.get("dying") or st.get("dead"):
+                break
+            near = self._approaching(st)
+            if near:
+                return await self._let_pass(5.0)
+            if not any(e["dx"] <= 9 and e["dy"] < 1 for e in st.get("enemies") or []):
+                break                                            # gone: the next decision runs on
+            await asyncio.sleep(0.1)
+        await self._down(R, S)
+        self._waited = True
+        return True
+
     async def _let_pass(self, seconds: float = 3.5) -> bool:
         """An enemy walking toward Mario is let under a standing jump: stop, wait until it is a
         tile away, jump straight up, land, run on. Measured six times out of six between 0.8 and
@@ -403,21 +434,72 @@ async def _approach(self) -> bool:
         st = await self._eval(STATE_JS)
         if not isinstance(st, dict) or not st.get("ready"):
             return False
+        if await self._eval("!!(player.resting && player.resting.title === 'Pipe')") and any(
+                e["dy"] < -1 and e["dx"] <= 9 for e in st.get("enemies") or []):
+            # from a pipe's top a jump lands nine tiles on, among the enemies below, and a step
+            # off the edge at a run dropped him onto them (both seen on the recording). Up here
+            # nothing reaches him: wait for the pair to be walking away and four tiles off, then
+            # step off slowly, and meet them at his height on the way
+            R, S = KEY["right"], KEY["sprint"]
+            await self._up(R, S)
+            for _ in range(70):                                  # up to 7 s
+                below = [e for e in st.get("enemies") or [] if e["dy"] < -1 and e["dx"] <= 9]
+                if not below or all(e.get("dir") == "away" and e["dx"] >= 4 for e in below):
+                    break
+                await asyncio.sleep(0.1)
+                st = await self._eval(STATE_JS)
+                if not isinstance(st, dict) or not st.get("ready"):
+                    return False
+            await self._down(R)                                  # a walk, not a run: drops a tile past the edge
+            for _ in range(40):
+                await asyncio.sleep(0.03)
+                if not await self._eval("!!(player.resting && player.resting.title === 'Pipe')"):
+                    break
+            await asyncio.sleep(0.5)
+            await self._down(R, S)
+            self._walked_off = True
+            return True
         near = self._approaching(st)
         slow_now = abs(st.get("xvel") or 0) < 3
-        # the standing jump that lets an enemy under is for one about to arrive, or for one under a
-        # block row (where a running jump hits the blocks and drops onto it); a farther one in the
-        # open is jumped at a run from four tiles, which lands well past it
-        if near and near["dx"] <= 6.5 and (near["dx"] <= 3.0 or slow_now or self._blocks_overhead(st)):
-            if await self._let_pass(5.0 if self._blocks_overhead(st) else 3.5):
+        # the standing jump that lets an enemy under is for a block row overhead (a running jump
+        # there hits the blocks and drops onto it) or for one already on a Mario with no speed;
+        # anything else in the open is jumped at a run from four tiles, which lands well past it
+        # (on the recording, waiting beside the pair for seconds ended in them every time)
+        if near and near["dx"] <= 6.5 and (self._blocks_overhead(st) or (near["dx"] <= 2.0 and slow_now)):
+            if await self._let_pass(5.0 if self._blocks_overhead(st) else 2.5):
                 return True
             st = await self._eval(STATE_JS)              # the enemy is gone; what is ahead now
             if not isinstance(st, dict) or not st.get("ready"):
                 return False
         target, want = self._target(st)
+        if target == "enemy" and want == "wait":
+            # without speed a forward jump lands a tile or two on, on the enemy (seen on the
+            # recording, four lives at the third pipe). One walking at him is let under; one
+            # walking away is waited for, since the pair turns at the next pipe and comes back
+            return await self._wait_enemy()
         if target is None or not isinstance(want, (int, float)):
             return False
         R, S, L = KEY["right"], KEY["sprint"], KEY["left"]
+        # a running jump lands about 9 tiles on; an enemy standing where it ends took a life at the
+        # 3-tile gap (twice) and beyond the fourth pipe (three times). One walking at Mario is let
+        # under first (a Goomba walking at a gap falls into it); one walking away is given time to
+        # leave; then the run-up
+        if target in ("gap", "wall"):
+            zone_from = self._distance(st, target) + 1.0
+            for _ in range(int((8.0 if target == "gap" else 3.0) / 0.1)):
+                zone = [e for e in st.get("enemies") or [] if zone_from <= e["dx"] <= zone_from + 9 and e["dy"] < 1]
+                if not zone:
+                    break
+                await self._up(R, S)                         # it comes to him (or into the gap); no jump into it
+                await asyncio.sleep(0.1)
+                st = await self._eval(STATE_JS)
+                if not isinstance(st, dict) or not st.get("ready") or st.get("dying") or st.get("dead"):
+                    return False
+                near = self._approaching(st)
+                if near and near["dx"] <= 1.2:
+                    if await self._let_pass(2.0):
+                        return True
+            await self._down(R, S)
         dx = self._distance(st, target)
         slow = abs(st.get("xvel") or 0) < 3
         if slow and dx < want + 1.5 and st.get("on_ground"):
@@ -463,8 +545,8 @@ def _blocks_overhead(st: dict) -> bool:
     def _approaching(st: dict):
         """The nearest enemy walking at Mario from either side, within reach of mattering."""
         en, back = st.get("enemies") or [], st.get("behind") or []
-        near = [e for e in en if e.get("dir") == "toward" and e["dx"] <= 12 and e["dy"] < 1]
-        near += [e for e in back if e.get("dir") == "toward" and e["dx"] <= 6 and e["dy"] < 1]
+        near = [{**e, "side": "ahead"} for e in en if e.get("dir") == "toward" and e["dx"] <= 12 and abs(e["dy"]) < 1]
+        near += [{**e, "side": "behind"} for e in back if e.get("dir") == "toward" and e["dx"] <= 6 and e["dy"] < 1]
         return min(near, key=lambda e: e["dx"]) if near else None
 
     @staticmethod
@@ -473,7 +555,7 @@ def _target(st: dict):
         None tiles meaning jump now."""
         near = []
         en, walls, gaps, blocks = st.get("enemies") or [], st.get("walls") or [], st.get("gaps") or [], st.get("blocks") or []
-        if en and en[0]["dx"] <= 10:
+        if en and en[0]["dx"] <= 10 and en[0]["dy"] < 1:
             near.append((en[0]["dx"], "enemy"))
         if blocks and blocks[0]["dx"] <= 6:
             near.append((blocks[0]["dx"], "block"))
@@ -488,9 +570,11 @@ def _target(st: dict):
         if kind == "wall":
             if walls[0]["height"] < TALL:
                 return None, None                       # any distance within a step clears it
-            return "wall", 2.4
+            return "wall", (2.4 if fast else 1.7)
         if kind == "enemy":
-            return ("enemy", 4.0) if fast and dx > 4.0 else (None, None)
+            if fast:
+                return ("enemy", 4.0) if dx > 4.0 else (None, None)
+            return "enemy", "wait"
         if kind == "block":
             # measured: at a run a medium jump started 1 to 1.5 tiles before the block hits it,
             # from 2 tiles or more it peaks short of it
@@ -573,8 +657,15 @@ async def go():
         if name == "walk_left":
             self._stopped = 0
         short = self._stopped_short if name == "run_right" else None
+        off = self._walked_off if name == "jump_right" else False
+        waited = self._waited if name == "jump_right" else False
+        self._walked_off = False
+        self._waited = False
         d["text"] = (f"{name} held {seconds:.2f} s" + (f" ({taken}: what lay ahead needed it)" if taken else "")
-                     + (f", stopped short of the {short['kind']}" if short else "") + ". " + d["text"])
+                     + (f", stopped short of the {short['kind']}" if short else "")
+                     + (" (walked off the pipe instead: the enemies below are where the jump would land)" if off else "")
+                     + (" (waited instead: a jump from a standstill lands on the enemy walking away)" if waited else "")
+                     + ". " + d["text"])
         return d
 
     def wait(self) -> dict:
@@ -684,9 +775,9 @@ def reset(goal: str = "") -> dict:
     # writes (0.7) the model was refused three times mid-air at 0.40 to 0.59 and the run stopped.
     keys = {"risk": "read"}
 
-    @m.tool(description="Run to the right, and keep running until told otherwise.", meta=keys)
-    def run_right(hold: Hold) -> dict:
-        return game.act("run_right", hold)
+    @m.tool(description="Run to the right for a moment, and keep running until told otherwise.", meta=keys)
+    def run_right() -> dict:
+        return game.act("run_right", "medium")
 
     @m.tool(description="Jump while running right, over an enemy, a gap or a wall ahead; the run continues after the jump.", meta=keys)
     def jump_right(hold: Hold) -> dict:

From b0cbb77a56f2334ee1314157d40015f86071aeec Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:09:45 -0700
Subject: [PATCH 10/26] mario: momentary actions, no waits: what the Jev demo
 does

The TypeSafe demo (x.com/faadilhshaik/status/2100086301894881578) decides about ten times a
second with momentary key states and bunny-hops the whole level at a run in 85 game seconds; the
recordings of this kit showed the opposite design, long actions with multi-second waits beside
enemies, is where the lives went. A run is now a moment of running (0.15 s), a jump is its hold
and nothing more, the flight is the next decision's business, and every wait is gone. What stays
is measured: the tall pipe's run-up to a take-off at 2.4 tiles (from every standing distance the
apex is 3.8 and the pipe is never cleared), the gap's edge, the block's 1 to 1.5 tiles, the peel
off a wall and the release that frees an embedded Mario. The kit asks for a step budget of 1200,
which a launch now carries (HarnessRouter 8b48cf4).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/kit.json                   |   4 +-
 kits/mario/plugin/server/mario_env.py | 269 ++++----------------------
 2 files changed, 45 insertions(+), 228 deletions(-)

diff --git a/kits/mario/kit.json b/kits/mario/kit.json
index 24d11a8..636e076 100644
--- a/kits/mario/kit.json
+++ b/kits/mario/kit.json
@@ -20,7 +20,9 @@
     ],
     "plugin": "plugin",
     "mcp_servers": [],
-    "system_prompt": "You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. Keep moving right. The state names any enemy, gap or wall that is within one step: jump over it now with jump_right, held as long as the state says. A question block overhead within one step pays a coin: jump_right under it. Otherwise run right. When Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left."
+    "system_prompt": "You play a side-scrolling platform game as Mario, deciding several times a second. Each step says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. Keep moving right, and jump often: a running jump clears an enemy, a pipe or a gap and lands well past it, so jump_right whenever anything is within one step, held as long as the state says. A question block overhead within one step pays a coin: jump_right under it. In the air, run_right keeps the run going. Otherwise run right. When Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left.",
+    "max_step": 1200,
+    "$comment": "max_step: a decision every few hundred milliseconds; the level takes a few hundred of them, and a death costs the way back."
   },
   "app": {
     "dir": "app",
diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 9c5e13d..5c12b87 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -31,15 +31,16 @@
 GAME_URL = os.environ.get("MARIO_URL", "https://supermarioplay.com/game/mario.html?v=1.0.1")
 TILE = 8                      # game units per tile; the game draws a tile as 8 * unitsize px
 HOLDS = {"short": 0.15, "medium": 0.35, "long": 0.6}
+RUN_MOMENT = 0.15          # a run action holds the keys this long, then the model decides again
 KEY = {"left": 37, "right": 39, "jump": 38, "down": 40, "sprint": 16}
 ITEMS = {"Coin", "Mushroom", "FireFlower", "Star", "Vine", "Text", "Shell", "Fireball"}
-INSTRUCTIONS = ("You play a side-scrolling platform game as Mario. Each step says where Mario is, whether he is on "
-                "the ground, and what is ahead with distances in tiles. One step lasts about half a second and "
-                "covers up to 4 tiles at a run. Keep moving right. The state names any enemy, gap or wall that is "
-                "within one step: jump over it now, with jump_right, held as long as the state says (a taller "
-                "wall or a wider gap needs a longer hold). A question block overhead within one step pays a coin: "
-                "jump_right under it. Otherwise run right. When Mario has just died, wait. Finish when the level "
-                "is cleared. Escalate when Mario has no lives left.")
+INSTRUCTIONS = ("You play a side-scrolling platform game as Mario, deciding several times a second. Each step "
+                "says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. "
+                "Keep moving right, and jump often: a running jump clears an enemy, a pipe or a gap and lands "
+                "well past it, so jump_right whenever anything is within one step, held as long as the state "
+                "says. A question block overhead within one step pays a coin: jump_right under it. In the air, "
+                "run_right keeps the run going. Otherwise run right. When Mario has just died, wait. Finish when "
+                "the level is cleared. Escalate when Mario has no lives left.")
 # Measured on the live game, feet above the ground at the apex: a short hold reaches 3.1 tiles, a
 # medium 3.9, a long 4.1, standing or at a run. So a 2-tile pipe takes a short hold, a 3-tile one a
 # medium, and a 4-tile one a long hold with the run-up the jump_right macro provides (from against
@@ -164,9 +165,7 @@ def __init__(self):
         self.steps = 0
         self.frames = 0
         self._stopped = 0          # consecutive runs that moved nothing
-        self._stopped_short = None # the enemy a run stopped short of, for the result text
-        self._walked_off = False   # a jump asked for on a pipe's top that became a step off it
-        self._waited = False       # a jump asked for beside an enemy walking away that became a wait
+        self._stopped_short = None # what a run stopped short of, for the result text
         self._lives = None
         self._restarting_until = 0.0
         self._held: set[int] = set()
@@ -241,33 +240,13 @@ async def _macro(self, name: str, hold: float) -> None:
             await self._down(R, S)
             self._stopped_short = None
             t0 = time.time()
-            while time.time() - t0 < hold:
+            while time.time() - t0 < RUN_MOMENT:
                 await asyncio.sleep(0.03)
                 st = await self._eval(STATE_JS)
                 if not isinstance(st, dict) or not st.get("ready"):
                     continue
-                en = self._approaching(st)
                 w = (st.get("walls") or [None])[0]
                 gap = (st.get("gaps") or [None])[0]
-                if en and en.get("side") == "behind":
-                    # one at his back is outrun; one already on him, with a wall ahead, is let under
-                    if en["dx"] <= 1.2 and w and w["dx"] <= 1.0:
-                        await self._up(R, S)
-                        await self._let_pass(2.0)
-                        self._stopped_short = {"kind": en["kind"] + " at his back, let under a jump"}
-                        break
-                    en = None
-                if en and en["dx"] <= 5.0 and abs(en["dy"]) < 1:
-                    # a run into an enemy walking at him ended in it every time (measured, nine
-                    # lives in one run); the run stops five tiles short, where the standing jump
-                    # that lets it under is taken from. One already within two tiles is let under
-                    # here and now: a decision later is a decision too late (measured at x 106)
-                    await self._up(R, S)
-                    self._stopped_short = {"kind": en["kind"] + " walking at him"}
-                    if en["dx"] <= 2.5:
-                        await self._let_pass(2.5)
-                        self._stopped_short = {"kind": en["kind"] + " walking at him, let under a jump"}
-                    break
                 if w and w["height"] >= TALL and w["dx"] <= 3.0:
                     # pressed against a tall pipe, a jump with the run key held rode up its side
                     # and left Mario embedded in it, "falling" in place (measured); the run stops
@@ -275,28 +254,27 @@ async def _macro(self, name: str, hold: float) -> None:
                     await self._up(R, S)
                     self._stopped_short = {"kind": f"{w['kind']} {w['height']} tiles tall"}
                     break
-                if gap and gap["dx"] <= 1.2 and st.get("on_ground"):
+                if gap and gap["dx"] <= (1.5 if st.get("on_ground") else 2.5):
+                    # a run carried into the gap after a landing beside it (recorded)
                     await self._up(R, S)
                     self._stopped_short = {"kind": "gap"}
                     break
         elif name == "jump_right":
             await self._up(L)
             await self._down(R, S)
-            await self._land()
-            await self._peel()
-            if await self._approach():          # the jump was taken inside (an enemy let under)
+            if not await self._eval("!!player.resting"):
+                await asyncio.sleep(RUN_MOMENT)          # in the air a jump is a moment of running
                 return
+            await self._peel()
+            await self._approach()
             await self._eval(f"keydown({U}); 'ok'")
             await asyncio.sleep(hold)
             await self._eval(f"keyup({U}); 'ok'")
-            await asyncio.sleep(max(0.0, 0.75 - hold))      # the flight, run key still down
         elif name == "jump":
             await self._up(R, S, L)
-            await self._land()
             await self._eval(f"keydown({U}); 'ok'")
             await asyncio.sleep(hold)
             await self._eval(f"keyup({U}); 'ok'")
-            await asyncio.sleep(max(0.0, 0.6 - hold))
         elif name == "walk_left":
             await self._up(R, S)
             await self._down(L)
@@ -306,18 +284,6 @@ async def _macro(self, name: str, hold: float) -> None:
             await self._up(R, S, L)
             await asyncio.sleep(0.25)
 
-    async def _land(self) -> None:
-        """A jump key pressed in the air does nothing in this game, so a jump asked for mid-flight
-        is taken on landing: the action means what it says instead of being spent. Mario held
-        against a pipe's side mid-air, "falling" in place at terminal speed (measured: yvel 7, no
-        movement, for seven decisions), is freed by letting go of the run key and stepping left."""
-        for i in range(30):
-            if await self._eval("!!player.resting || !!player.dead || !!player.dying"):
-                return
-            if i == 12:
-                await self._unstick()
-            await asyncio.sleep(0.03)
-
     async def _unstick(self) -> None:
         """Held into a pipe's side in the air, Mario "falls" in place at terminal speed for as long
         as a key is held (measured: yvel 7, no movement, a whole life against the fourth pipe).
@@ -366,149 +332,27 @@ def _needed_hold(self) -> str | None:
             return hold_for(walls[0]["height"])
         return None
 
-    async def _wait_enemy(self) -> bool:
-        R, S = KEY["right"], KEY["sprint"]
-        await self._up(R, S)
-        for _ in range(60):                                      # up to 6 s
-            st = await self._eval(STATE_JS)
-            if not isinstance(st, dict) or not st.get("ready") or st.get("dying") or st.get("dead"):
-                break
-            near = self._approaching(st)
-            if near:
-                return await self._let_pass(5.0)
-            if not any(e["dx"] <= 9 and e["dy"] < 1 for e in st.get("enemies") or []):
-                break                                            # gone: the next decision runs on
-            await asyncio.sleep(0.1)
-        await self._down(R, S)
-        self._waited = True
-        return True
-
-    async def _let_pass(self, seconds: float = 3.5) -> bool:
-        """An enemy walking toward Mario is let under a standing jump: stop, wait until it is a
-        tile away, jump straight up, land, run on. Measured six times out of six between 0.8 and
-        1.2 tiles with a medium hold; a running jump over the first Goomba hit the block row above
-        it and dropped Mario onto it, every life. Returns whether the jump was taken here."""
-        R, S, U = KEY["right"], KEY["sprint"], KEY["jump"]
-        await self._up(R, S)
-        for _ in range(int(seconds / 0.02)):
-            await asyncio.sleep(0.02)
-            st = await self._eval(STATE_JS)
-            if not isinstance(st, dict) or not st.get("ready") or st.get("dying") or st.get("dead"):
-                await self._down(R, S)
-                return True
-            en = self._approaching(st)
-            if not en:
-                break                            # gone, or turned away: the running jump follows
-            if en["dy"] < -1:
-                continue                         # below him (he stands on something): it cannot reach him; let it pass or turn
-            if st.get("on_ground") and (en["dx"] <= 0.6 or (en["dx"] <= 1.0 and abs(st.get("xvel") or 0) < 0.6)):
-                w = (st.get("walls") or [None])[0]
-                if w and w["dx"] <= 0.05:
-                    # against a pipe, a jump here followed by the run key mid-air rode up its side
-                    # and embedded him (measured: every life at the fourth pipe); a step back first
-                    await self._down(KEY["left"])
-                    await asyncio.sleep(0.12)
-                    await self._up(KEY["left"])
-                await self._eval(f"keydown({U}); 'ok'")
-                await asyncio.sleep(HOLDS["medium"])
-                await self._eval(f"keyup({U}); 'ok'")
-                for _ in range(40):                  # the run key comes back on the ground, never against a wall in the air
-                    await asyncio.sleep(0.03)
-                    if await self._eval("!!player.resting || !!player.dead || !!player.dying"):
-                        break
-                await self._down(R, S)
-                return True
-        await self._down(R, S)
-        return False
-
-    async def _approach(self) -> bool:
-        """The model decides to jump; when to leave the ground is the environment's, the way
-        holding the keys is. A decision lands every half second or so and a jump is a one-tile
-        affair, so a jump taken the moment it is chosen is early or late by luck. Measured on the
-        live game: a wall 4 tiles tall is cleared by a long jump from 1.5 to 3 tiles back and from
-        nowhere else (from against it the apex is level with the top; at a run from 4 back it
-        peaks early and hits the side); a running jump covers about 9 tiles, so a gap is best left
-        from its edge at speed; an enemy walking at Mario is let under a standing jump (see
-        _let_pass). So: an approaching enemy first; then keep running until the nearest thing
-        ahead is at its distance, backing off first when there is no room for the run-up."""
+    async def _approach(self) -> None:
+        """The model decides to jump; where to leave the ground is the environment's, the way
+        holding the keys is, for the two things a jump's timing decides. Measured on the live
+        game: a wall 4 tiles tall is cleared only by a long jump at speed, taken 2.4 tiles back
+        after a run-up (from against it the apex is level with the top, and from every standing
+        distance the apex is 3.8); a gap is best left from its edge. Everything else is jumped
+        where the model asked: a running jump lands nine tiles on, and standing beside an enemy
+        to time anything cost more lives than it saved (recorded)."""
         st = await self._eval(STATE_JS)
         if not isinstance(st, dict) or not st.get("ready"):
-            return False
-        if await self._eval("!!(player.resting && player.resting.title === 'Pipe')") and any(
-                e["dy"] < -1 and e["dx"] <= 9 for e in st.get("enemies") or []):
-            # from a pipe's top a jump lands nine tiles on, among the enemies below, and a step
-            # off the edge at a run dropped him onto them (both seen on the recording). Up here
-            # nothing reaches him: wait for the pair to be walking away and four tiles off, then
-            # step off slowly, and meet them at his height on the way
-            R, S = KEY["right"], KEY["sprint"]
-            await self._up(R, S)
-            for _ in range(70):                                  # up to 7 s
-                below = [e for e in st.get("enemies") or [] if e["dy"] < -1 and e["dx"] <= 9]
-                if not below or all(e.get("dir") == "away" and e["dx"] >= 4 for e in below):
-                    break
-                await asyncio.sleep(0.1)
-                st = await self._eval(STATE_JS)
-                if not isinstance(st, dict) or not st.get("ready"):
-                    return False
-            await self._down(R)                                  # a walk, not a run: drops a tile past the edge
-            for _ in range(40):
-                await asyncio.sleep(0.03)
-                if not await self._eval("!!(player.resting && player.resting.title === 'Pipe')"):
-                    break
-            await asyncio.sleep(0.5)
-            await self._down(R, S)
-            self._walked_off = True
-            return True
-        near = self._approaching(st)
-        slow_now = abs(st.get("xvel") or 0) < 3
-        # the standing jump that lets an enemy under is for a block row overhead (a running jump
-        # there hits the blocks and drops onto it) or for one already on a Mario with no speed;
-        # anything else in the open is jumped at a run from four tiles, which lands well past it
-        # (on the recording, waiting beside the pair for seconds ended in them every time)
-        if near and near["dx"] <= 6.5 and (self._blocks_overhead(st) or (near["dx"] <= 2.0 and slow_now)):
-            if await self._let_pass(5.0 if self._blocks_overhead(st) else 2.5):
-                return True
-            st = await self._eval(STATE_JS)              # the enemy is gone; what is ahead now
-            if not isinstance(st, dict) or not st.get("ready"):
-                return False
+            return
         target, want = self._target(st)
-        if target == "enemy" and want == "wait":
-            # without speed a forward jump lands a tile or two on, on the enemy (seen on the
-            # recording, four lives at the third pipe). One walking at him is let under; one
-            # walking away is waited for, since the pair turns at the next pipe and comes back
-            return await self._wait_enemy()
-        if target is None or not isinstance(want, (int, float)):
-            return False
+        if target is None:
+            return
         R, S, L = KEY["right"], KEY["sprint"], KEY["left"]
-        # a running jump lands about 9 tiles on; an enemy standing where it ends took a life at the
-        # 3-tile gap (twice) and beyond the fourth pipe (three times). One walking at Mario is let
-        # under first (a Goomba walking at a gap falls into it); one walking away is given time to
-        # leave; then the run-up
-        if target in ("gap", "wall"):
-            zone_from = self._distance(st, target) + 1.0
-            for _ in range(int((8.0 if target == "gap" else 3.0) / 0.1)):
-                zone = [e for e in st.get("enemies") or [] if zone_from <= e["dx"] <= zone_from + 9 and e["dy"] < 1]
-                if not zone:
-                    break
-                await self._up(R, S)                         # it comes to him (or into the gap); no jump into it
-                await asyncio.sleep(0.1)
-                st = await self._eval(STATE_JS)
-                if not isinstance(st, dict) or not st.get("ready") or st.get("dying") or st.get("dead"):
-                    return False
-                near = self._approaching(st)
-                if near and near["dx"] <= 1.2:
-                    if await self._let_pass(2.0):
-                        return True
-            await self._down(R, S)
         dx = self._distance(st, target)
         slow = abs(st.get("xvel") or 0) < 3
-        if slow and dx < want + 1.5 and st.get("on_ground"):
-            # no room for the run-up: step back first, unless something is there. A jump from
-            # 1.6 tiles back with no speed cleared the pipe and landed 2 tiles past it, on the
-            # enemies that pace there (measured: four lives in a row); three tiles of run-up
-            # give the jump its speed and the landing its distance
-            if any(b["dx"] <= 3.5 or (b.get("dir") == "toward" and b["dx"] <= 6) for b in st.get("behind") or []):
-                return False
+        if target == "wall" and slow and dx < want + 1.5 and st.get("on_ground"):
+            # no room for the run-up: step back first, unless something is at his back
+            if any(b["dx"] <= 3.5 for b in st.get("behind") or []):
+                return
             await self._up(R, S)
             await self._down(L)
             for _ in range(70):
@@ -525,56 +369,33 @@ async def _approach(self) -> bool:
             await asyncio.sleep(0.03)
             st = await self._eval(STATE_JS)
             if not isinstance(st, dict) or st.get("dying") or st.get("dead"):
-                return False
+                return
             if self._distance(st, target) <= want:
-                return False
-        return False
+                return
 
     @staticmethod
     def _distance(st: dict, kind: str) -> float:
         rows = st.get({"enemy": "enemies", "wall": "walls", "gap": "gaps", "block": "blocks"}[kind]) or []
         return rows[0]["dx"] if rows else 99.0
 
-    @staticmethod
-    def _blocks_overhead(st: dict) -> bool:
-        """A block row within a running jump's flight: the state drops question blocks near an
-        enemy, so the fields carry the row for this purpose."""
-        return any(b["dx"] <= 6 for b in st.get("overhead") or [])
-
-    @staticmethod
-    def _approaching(st: dict):
-        """The nearest enemy walking at Mario from either side, within reach of mattering."""
-        en, back = st.get("enemies") or [], st.get("behind") or []
-        near = [{**e, "side": "ahead"} for e in en if e.get("dir") == "toward" and e["dx"] <= 12 and abs(e["dy"]) < 1]
-        near += [{**e, "side": "behind"} for e in back if e.get("dir") == "toward" and e["dx"] <= 6 and e["dy"] < 1]
-        return min(near, key=lambda e: e["dx"]) if near else None
-
     @staticmethod
     def _target(st: dict):
-        """What the jump is for and the distance to leave the ground at: (kind, tiles), with
-        None tiles meaning jump now."""
+        """What the jump's timing is for and the distance to leave the ground at: (kind, tiles),
+        or (None, None) for a jump taken where the model asked."""
+        walls, gaps, blocks = st.get("walls") or [], st.get("gaps") or [], st.get("blocks") or []
         near = []
-        en, walls, gaps, blocks = st.get("enemies") or [], st.get("walls") or [], st.get("gaps") or [], st.get("blocks") or []
-        if en and en[0]["dx"] <= 10 and en[0]["dy"] < 1:
-            near.append((en[0]["dx"], "enemy"))
-        if blocks and blocks[0]["dx"] <= 6:
-            near.append((blocks[0]["dx"], "block"))
-        if walls and walls[0]["dx"] <= 6:
+        if walls and walls[0]["dx"] <= 6 and walls[0]["height"] >= TALL:
             near.append((walls[0]["dx"], "wall"))
         if gaps and gaps[0]["dx"] <= 6:
             near.append((gaps[0]["dx"], "gap"))
+        if blocks and blocks[0]["dx"] <= 6:
+            near.append((blocks[0]["dx"], "block"))
         if not near:
             return None, None
         dx, kind = min(near)
         fast = abs(st.get("xvel") or 0) >= 3
         if kind == "wall":
-            if walls[0]["height"] < TALL:
-                return None, None                       # any distance within a step clears it
-            return "wall", (2.4 if fast else 1.7)
-        if kind == "enemy":
-            if fast:
-                return ("enemy", 4.0) if dx > 4.0 else (None, None)
-            return "enemy", "wait"
+            return "wall", 2.4
         if kind == "block":
             # measured: at a run a medium jump started 1 to 1.5 tiles before the block hits it,
             # from 2 tiles or more it peaks short of it
@@ -657,15 +478,9 @@ async def go():
         if name == "walk_left":
             self._stopped = 0
         short = self._stopped_short if name == "run_right" else None
-        off = self._walked_off if name == "jump_right" else False
-        waited = self._waited if name == "jump_right" else False
-        self._walked_off = False
-        self._waited = False
+
         d["text"] = (f"{name} held {seconds:.2f} s" + (f" ({taken}: what lay ahead needed it)" if taken else "")
-                     + (f", stopped short of the {short['kind']}" if short else "")
-                     + (" (walked off the pipe instead: the enemies below are where the jump would land)" if off else "")
-                     + (" (waited instead: a jump from a standstill lands on the enemy walking away)" if waited else "")
-                     + ". " + d["text"])
+                     + (f", stopped short of the {short['kind']}" if short else "") + ". " + d["text"])
         return d
 
     def wait(self) -> dict:

From 0d12ca1541a731e0add6df5ecaaa554c6dbb41af Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:24:07 -0700
Subject: [PATCH 11/26] mario: the environment executes key states and times
 nothing; the facts are in the instructions

First principles, at Richard's insistence: the environment is a faithful, fast interface to the
game, the intelligence is the model's, and the measured facts of the game are instructions a
person can read and edit in the harness. Each action sets the keys for a tick (0.1 s) and they
stay set until the next action, the way a thumb does: run_right, jump_right, jump, walk_left,
wait, no parameters. The state says which keys are held, that a held jump must be let go before
another, what a decision covers at the speed there is, and what each wall and gap takes; the
system prompt carries the jump heights, the run-up a 4-tile pipe needs, the let-under for an
enemy walking at Mario, the block row and the coins. The run-ups, edge jumps, let-unders and
waits the environment used to script are gone with the hold parameters; what stays is the
release that frees a Mario embedded in a pipe's side, a glitch rather than play. The observation
declares itself real-time for the harness (System One Harness 0.3.0).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/kit.json                   |   4 +-
 kits/mario/plugin/server/mario_env.py | 298 ++++++--------------------
 2 files changed, 67 insertions(+), 235 deletions(-)

diff --git a/kits/mario/kit.json b/kits/mario/kit.json
index 636e076..5278677 100644
--- a/kits/mario/kit.json
+++ b/kits/mario/kit.json
@@ -20,9 +20,9 @@
     ],
     "plugin": "plugin",
     "mcp_servers": [],
-    "system_prompt": "You play a side-scrolling platform game as Mario, deciding several times a second. Each step says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. Keep moving right, and jump often: a running jump clears an enemy, a pipe or a gap and lands well past it, so jump_right whenever anything is within one step, held as long as the state says. A question block overhead within one step pays a coin: jump_right under it. In the air, run_right keeps the run going. Otherwise run right. When Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left.",
+    "system_prompt": "You play a side-scrolling platform game as Mario, deciding several times a second. Each action sets the keys for the next moment and they stay set until you change them: run_right holds right and run; jump_right holds right, run and jump; jump holds jump alone; walk_left holds left; wait lets every key go. Keep moving right.\n\nFacts, measured on this game: a decision lands about every third of a second, and at a full run Mario covers about 3 tiles between decisions. A jump held for one decision clears 3 tiles, for two decisions 4 tiles; the jump key must be let go (run_right or wait) before Mario can jump again. A running jump lands about 9 tiles on. A pipe 4 tiles tall is cleared only from a run, leaving the ground 2 to 3 tiles before it with the jump held for three decisions; from against it, or from standing, it is never cleared, so if Mario is stopped at one, walk_left for two decisions, then run_right, then jump_right at 2 to 3 tiles. A gap is crossed by a running jump from its edge; a standing jump falls in. An enemy walking at Mario is safest let under a standing jump: wait until it is about one tile away, then jump; a running jump taken with it 2 tiles away hits it. Under a row of blocks a running jump hits the blocks and drops onto whatever is below, so let the first enemy under a standing jump. A question block is hit from below by a jump started 1 to 1.5 tiles before it at a run, and pays a coin. Enemies behind Mario are outrun.\n\nWhen Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left.",
     "max_step": 1200,
-    "$comment": "max_step: a decision every few hundred milliseconds; the level takes a few hundred of them, and a death costs the way back."
+    "$comment": "system_prompt carries the measured facts of this game; the environment executes key states and times nothing. max_step: a decision every third of a second, the level takes a few hundred, and a death costs the way back."
   },
   "app": {
     "dir": "app",
diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 5c12b87..76d6e25 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -24,31 +24,21 @@
 import sys
 import threading
 import time
-from typing import Annotated
 
-from pydantic import Field
 
 GAME_URL = os.environ.get("MARIO_URL", "https://supermarioplay.com/game/mario.html?v=1.0.1")
 TILE = 8                      # game units per tile; the game draws a tile as 8 * unitsize px
-HOLDS = {"short": 0.15, "medium": 0.35, "long": 0.6}
-RUN_MOMENT = 0.15          # a run action holds the keys this long, then the model decides again
+TICK = 0.10                   # an action sets the keys and holds them this long; they stay set until the next
 KEY = {"left": 37, "right": 39, "jump": 38, "down": 40, "sprint": 16}
+KEY_NAMES = {37: "left", 39: "right", 38: "jump", 40: "down", 16: "run"}
 ITEMS = {"Coin", "Mushroom", "FireFlower", "Star", "Vine", "Text", "Shell", "Fireball"}
-INSTRUCTIONS = ("You play a side-scrolling platform game as Mario, deciding several times a second. Each step "
-                "says where Mario is, whether he is on the ground, and what is ahead with distances in tiles. "
-                "Keep moving right, and jump often: a running jump clears an enemy, a pipe or a gap and lands "
-                "well past it, so jump_right whenever anything is within one step, held as long as the state "
-                "says. A question block overhead within one step pays a coin: jump_right under it. In the air, "
-                "run_right keeps the run going. Otherwise run right. When Mario has just died, wait. Finish when "
+INSTRUCTIONS = ("You play a side-scrolling platform game as Mario, deciding several times a second. Each action sets "
+                "the keys for the next moment and they stay set until you change them: run_right holds right and run, "
+                "jump_right holds right, run and jump, jump holds jump alone, walk_left holds left, wait lets every "
+                "key go. The state says where Mario is, what he is doing, what is ahead and behind with distances in "
+                "tiles, and which keys are held. Keep moving right and jump over what is within one step. Finish when "
                 "the level is cleared. Escalate when Mario has no lives left.")
-# Measured on the live game, feet above the ground at the apex: a short hold reaches 3.1 tiles, a
-# medium 3.9, a long 4.1, standing or at a run. So a 2-tile pipe takes a short hold, a 3-tile one a
-# medium, and a 4-tile one a long hold with the run-up the jump_right macro provides (from against
-# it the apex is level with the top and the side blocks the way; from 1.5 to 3 tiles back it clears).
-def hold_for(height: float) -> str:
-    return "short" if height <= 2 else "medium" if height <= 3 else "long"
-
-TALL = 4          # a wall this tall needs the run-up
+TALL = 4                      # a wall this tall is cleared only at a run
 # The frame the kit's page shows: Chrome's own screencast, a JPEG for every third frame the game
 # draws (about twenty a second), each written whole to frame.jpg. The page reads that file.
 SCREENCAST = {"format": "jpeg", "quality": 45, "maxWidth": 960, "maxHeight": 600, "everyNthFrame": 3}
@@ -76,7 +66,7 @@ def hold_for(height: float) -> str:
     if (dx >= 0 && dx <= 12) enemies.push({kind: c.title, dx: Math.round(dx * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) < 0 ? 'toward' : 'away'});
     else if (back >= 0 && back <= 8) behind.push({kind: c.title, dx: Math.round(back * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) > 0 ? 'toward' : 'away'});
   });
-  var floors = (window.solids || []).filter(function(s){ return s.alive && s.title === 'Floor' && s.top >= p.bottom - 4; });
+  var floors = (window.solids || []).filter(function(s){ return s.alive && (s.title === 'Floor' || s.title === 'Stone') && s.top >= p.bottom - 4; });
   var x = p.right, gapStart = null;
   for (var i = 0; i <= 12 * T; i += T / 4) {
     var covered = floors.some(function(f){ return f.left <= x + i && x + i <= f.right; });
@@ -165,7 +155,7 @@ def __init__(self):
         self.steps = 0
         self.frames = 0
         self._stopped = 0          # consecutive runs that moved nothing
-        self._stopped_short = None # what a run stopped short of, for the result text
+
         self._lives = None
         self._restarting_until = 0.0
         self._held: set[int] = set()
@@ -217,7 +207,13 @@ async def _eval(self, expression: str):
                                                              session_id=self._cdp.session_id)
         return (r.get("result") or {}).get("value")
 
-    async def _down(self, *codes: int) -> None:
+    async def _keys(self, *codes: int) -> None:
+        """Set the held keys to exactly these: press what is missing, release the rest. A key
+        stays down across decisions until an action leaves it out, the way a thumb does."""
+        for c in list(self._held):
+            if c not in codes:
+                await self._eval(f"keyup({c}); 'ok'")
+                self._held.discard(c)
         for c in codes:
             if c not in self._held:
                 await self._eval(f"keydown({c}); 'ok'")
@@ -229,60 +225,14 @@ async def _up(self, *codes: int) -> None:
                 await self._eval(f"keyup({c}); 'ok'")
                 self._held.discard(c)
 
-    async def _macro(self, name: str, hold: float) -> None:
-        """The keys stay where a macro leaves them: running stays running between decisions, and a
-        jump keeps the run key down for the whole flight. Releasing everything after each hold
-        left Mario braking mid-air and landing short of the enemy he had jumped for (measured:
-        five deaths in twenty-nine actions with released keys)."""
+    async def _tick(self, name: str) -> None:
+        """The key state each action means, held for one tick. The environment executes; it
+        does not time anything for the model: where to leave the ground is the model's call,
+        from the facts the state and its instructions carry."""
         R, S, U, L = KEY["right"], KEY["sprint"], KEY["jump"], KEY["left"]
-        if name == "run_right":
-            await self._up(L)
-            await self._down(R, S)
-            self._stopped_short = None
-            t0 = time.time()
-            while time.time() - t0 < RUN_MOMENT:
-                await asyncio.sleep(0.03)
-                st = await self._eval(STATE_JS)
-                if not isinstance(st, dict) or not st.get("ready"):
-                    continue
-                w = (st.get("walls") or [None])[0]
-                gap = (st.get("gaps") or [None])[0]
-                if w and w["height"] >= TALL and w["dx"] <= 3.0:
-                    # pressed against a tall pipe, a jump with the run key held rode up its side
-                    # and left Mario embedded in it, "falling" in place (measured); the run stops
-                    # where the jump's run-up starts
-                    await self._up(R, S)
-                    self._stopped_short = {"kind": f"{w['kind']} {w['height']} tiles tall"}
-                    break
-                if gap and gap["dx"] <= (1.5 if st.get("on_ground") else 2.5):
-                    # a run carried into the gap after a landing beside it (recorded)
-                    await self._up(R, S)
-                    self._stopped_short = {"kind": "gap"}
-                    break
-        elif name == "jump_right":
-            await self._up(L)
-            await self._down(R, S)
-            if not await self._eval("!!player.resting"):
-                await asyncio.sleep(RUN_MOMENT)          # in the air a jump is a moment of running
-                return
-            await self._peel()
-            await self._approach()
-            await self._eval(f"keydown({U}); 'ok'")
-            await asyncio.sleep(hold)
-            await self._eval(f"keyup({U}); 'ok'")
-        elif name == "jump":
-            await self._up(R, S, L)
-            await self._eval(f"keydown({U}); 'ok'")
-            await asyncio.sleep(hold)
-            await self._eval(f"keyup({U}); 'ok'")
-        elif name == "walk_left":
-            await self._up(R, S)
-            await self._down(L)
-            await asyncio.sleep(hold)
-            await self._up(L)
-        else:
-            await self._up(R, S, L)
-            await asyncio.sleep(0.25)
+        keys = {"run_right": (R, S), "jump_right": (R, S, U), "jump": (U,), "walk_left": (L,), "wait": ()}[name]
+        await self._keys(*keys)
+        await asyncio.sleep(TICK)
 
     async def _unstick(self) -> None:
         """Held into a pipe's side in the air, Mario "falls" in place at terminal speed for as long
@@ -304,105 +254,6 @@ async def _unstick(self) -> None:
         if KEY["right"] in held:
             await self._down(KEY["right"], KEY["sprint"])
 
-    async def _peel(self) -> None:
-        """Overlapping a wall's edge (he stops a tenth of a tile inside it), a jump with the run key
-        held rides up its side and embeds him. A short step back first, and the jump is a jump."""
-        st = await self._eval(STATE_JS)
-        w = ((st or {}).get("walls") or [None])[0] if isinstance(st, dict) else None
-        if w and w["dx"] <= 0.05 and st.get("on_ground"):
-            await self._up(KEY["right"], KEY["sprint"])
-            await self._down(KEY["left"])
-            await asyncio.sleep(0.12)
-            await self._up(KEY["left"])
-            await asyncio.sleep(0.1)
-            await self._down(KEY["right"], KEY["sprint"])
-
-    def _needed_hold(self) -> str | None:
-        """The hold the nearest gap or wall within a step needs. A short hop into a gap and a
-        medium jump at a 4-tile pipe each cost a life (measured), so the environment takes the
-        hold the obstacle needs when the model's is shorter, and says so in the result."""
-        st = self._run(self._eval(STATE_JS), 10)
-        if not isinstance(st, dict) or not st.get("ready"):
-            return None
-        reach = max(1.0, abs(st.get("xvel") or 0) * 60 * 0.6 / (8 * 4))
-        gaps, walls = st.get("gaps") or [], st.get("walls") or []
-        if gaps and gaps[0]["dx"] <= reach + 0.5:
-            return "long"
-        if walls and walls[0]["dx"] <= reach + 0.5:
-            return hold_for(walls[0]["height"])
-        return None
-
-    async def _approach(self) -> None:
-        """The model decides to jump; where to leave the ground is the environment's, the way
-        holding the keys is, for the two things a jump's timing decides. Measured on the live
-        game: a wall 4 tiles tall is cleared only by a long jump at speed, taken 2.4 tiles back
-        after a run-up (from against it the apex is level with the top, and from every standing
-        distance the apex is 3.8); a gap is best left from its edge. Everything else is jumped
-        where the model asked: a running jump lands nine tiles on, and standing beside an enemy
-        to time anything cost more lives than it saved (recorded)."""
-        st = await self._eval(STATE_JS)
-        if not isinstance(st, dict) or not st.get("ready"):
-            return
-        target, want = self._target(st)
-        if target is None:
-            return
-        R, S, L = KEY["right"], KEY["sprint"], KEY["left"]
-        dx = self._distance(st, target)
-        slow = abs(st.get("xvel") or 0) < 3
-        if target == "wall" and slow and dx < want + 1.5 and st.get("on_ground"):
-            # no room for the run-up: step back first, unless something is at his back
-            if any(b["dx"] <= 3.5 for b in st.get("behind") or []):
-                return
-            await self._up(R, S)
-            await self._down(L)
-            for _ in range(70):
-                await asyncio.sleep(0.03)
-                st = await self._eval(STATE_JS)
-                if not isinstance(st, dict) or st.get("dying") or st.get("dead"):
-                    break
-                if self._distance(st, target) >= want + 3.0:
-                    break
-            await self._up(L)
-            await self._down(R, S)
-            await asyncio.sleep(0.05)
-        for _ in range(40):                        # at most 1.2 s of running
-            await asyncio.sleep(0.03)
-            st = await self._eval(STATE_JS)
-            if not isinstance(st, dict) or st.get("dying") or st.get("dead"):
-                return
-            if self._distance(st, target) <= want:
-                return
-
-    @staticmethod
-    def _distance(st: dict, kind: str) -> float:
-        rows = st.get({"enemy": "enemies", "wall": "walls", "gap": "gaps", "block": "blocks"}[kind]) or []
-        return rows[0]["dx"] if rows else 99.0
-
-    @staticmethod
-    def _target(st: dict):
-        """What the jump's timing is for and the distance to leave the ground at: (kind, tiles),
-        or (None, None) for a jump taken where the model asked."""
-        walls, gaps, blocks = st.get("walls") or [], st.get("gaps") or [], st.get("blocks") or []
-        near = []
-        if walls and walls[0]["dx"] <= 6 and walls[0]["height"] >= TALL:
-            near.append((walls[0]["dx"], "wall"))
-        if gaps and gaps[0]["dx"] <= 6:
-            near.append((gaps[0]["dx"], "gap"))
-        if blocks and blocks[0]["dx"] <= 6:
-            near.append((blocks[0]["dx"], "block"))
-        if not near:
-            return None, None
-        dx, kind = min(near)
-        fast = abs(st.get("xvel") or 0) >= 3
-        if kind == "wall":
-            return "wall", 2.4
-        if kind == "block":
-            # measured: at a run a medium jump started 1 to 1.5 tiles before the block hits it,
-            # from 2 tiles or more it peaks short of it
-            want = 1.3 if fast else 0.5
-            return ("block", want) if dx > want else (None, None)
-        return "gap", 1.5
-
     # ── the tools ──
     def reset(self, goal: str) -> dict:
         async def go():
@@ -456,51 +307,29 @@ def _restarting(self, st: dict) -> bool:
             self._restarting_until = max(self._restarting_until, time.time() + 3.0)
         return time.time() < self._restarting_until
 
-    def act(self, name: str, hold: str) -> dict:
-        seconds = HOLDS.get(hold, HOLDS["medium"])
-        needed = self._needed_hold() if name == "jump_right" else None
-        taken = needed if needed and HOLDS[needed] > seconds else None
-        if taken:
-            seconds = HOLDS[taken]
-
+    def act(self, name: str) -> dict:
         async def go():
             await self._start()
-            await self._macro(name, seconds)
-            await asyncio.sleep(0.05)
+            await self._tick(name)
             return await self._settled()
         st = self._run(go())
         self.steps += 1
-        if name in ("run_right", "jump_right") and st.get("on_ground") and abs(st.get("xvel") or 0) < 0.5 and not st.get("dying"):
-            self._stopped += 1
-        else:
-            self._stopped = 0
+        stuck = name in ("run_right", "jump_right") and st.get("on_ground") and abs(st.get("xvel") or 0) < 0.5 and not st.get("dying")
+        self._stopped = self._stopped + 1 if stuck else 0
         d = self._describe(st)
-        if name == "walk_left":
-            self._stopped = 0
-        short = self._stopped_short if name == "run_right" else None
-
-        d["text"] = (f"{name} held {seconds:.2f} s" + (f" ({taken}: what lay ahead needed it)" if taken else "")
-                     + (f", stopped short of the {short['kind']}" if short else "") + ". " + d["text"])
-        return d
-
-    def wait(self) -> dict:
-        async def go():
-            await self._start()
-            await self._macro("wait", 0.25)
-            return await self._settled()
-        d = self._describe(self._run(go()))
-        d["text"] = "Waited 0.25 s. " + d["text"]
+        held = "+".join(KEY_NAMES[c] for c in sorted(self._held, key=lambda c: list(KEY_NAMES).index(c))) or "nothing"
+        d["text"] = f"{name}: holding {held}. " + d["text"]
         return d
 
     def _describe(self, st: dict) -> dict:
         if not st.get("ready"):
-            return {"ok": True, "text": "The game is loading.", "fields": {"ready": False}, "candidates": {}, "terminal": False}
+            return {"ok": True, "text": "The game is loading.", "fields": {"ready": False}, "candidates": {}, "terminal": False, "realtime": True}
         restarting = self._restarting(st)
         if restarting:
             lives = st.get("lives")
             return {"ok": True, "text": f"Mario has just died. Lives left: {lives}. The level restarts from the beginning in a moment; wait.",
                     "fields": {"dead": True, "lives": lives, "restarting": True}, "candidates": {},
-                    "terminal": bool(lives is not None and lives <= 0)}
+                    "terminal": bool(lives is not None and lives <= 0), "realtime": True}
         parts = []
         if st.get("dead"):
             parts.append("Mario has just died; the level restarts in a moment.")
@@ -521,13 +350,14 @@ def _describe(self, st: dict) -> dict:
             b = back[0]
             parts.append(f"Behind Mario: {b['kind']} {b['dx']} tiles back, walking {'toward him' if b.get('dir') == 'toward' else 'away'}.")
         gaps = st.get("gaps") or []
-        parts.append(f"Gap in the ground: edge {gaps[0]['dx']} tiles ahead, {gaps[0]['width']} tiles wide." if gaps
+        parts.append(f"Gap in the ground: edge {gaps[0]['dx']} tiles ahead, {gaps[0]['width']} tiles wide; a running jump from the edge crosses it, a standing one falls in." if gaps
                      else "No gap in the ground within 12 tiles.")
         walls = st.get("walls") or []
         if walls:
             w = walls[0]
-            parts.append(f"Wall ahead: {w['kind']} {w['dx']} tiles ahead, {w['height']} tiles tall; "
-                         f"jump_right held {hold_for(w['height'])} clears it.")
+            need = ("a jump held for three decisions from a run, leaving the ground 2 to 3 tiles before it; from against it or from standing it is never cleared"
+                    if w["height"] >= TALL else "a jump held for two decisions" if w["height"] >= 3 else "a jump")
+            parts.append(f"Wall ahead: {w['kind']} {w['dx']} tiles ahead, {w['height']} tiles tall; it takes {need}.")
         else:
             parts.append("No pipe or wall within 8 tiles.")
         blocks = st.get("blocks") or []
@@ -541,29 +371,35 @@ def _describe(self, st: dict) -> dict:
         # to 7.8 tiles a step (11.5 -> 6 -> 1.3; 9.8 -> 2), a standing wall about 4; the hold, the
         # model's answer and the enemy's own walk all fit in one step, and an enemy 2 tiles away
         # at a run is already too close to jump, so it is named a step earlier than it arrives
-        reach = round(max(1.0, abs(st.get("xvel") or 0) * 60 * 0.6 / (8 * 4)), 1)
-        closing = round(reach + 1.5, 1)
+        # measured: a decision lands about every 0.35 s; at a full run (9 tiles a second) that is
+        # 3 tiles, and a walking enemy adds about half a tile of its own
+        reach = round(max(0.5, abs(st.get("xvel") or 0) * 60 * 0.35 / (8 * 4)), 1)
+        closing = round(reach + 0.6, 1)
         within = [f"the {en[0]['kind']} {en[0]['dx']} tiles ahead"] if en and en[0]["dx"] <= closing + 2.5 else []
-        within += [f"the gap {gaps[0]['dx']} tiles ahead (hold long)"] if gaps and gaps[0]["dx"] <= reach + 0.5 else []
-        within += [f"the {walls[0]['kind']} {walls[0]['dx']} tiles ahead (hold {hold_for(walls[0]['height'])})"] if walls and walls[0]["dx"] <= reach + 0.5 else []
-        within += [f"the question block {blocks[0]['dx']} tiles ahead (hold medium)"] if blocks and blocks[0]["dx"] <= reach + 0.5 else []
-        parts.append(f"One step reaches about {reach} tiles, and a walking enemy closes about {closing}. "
+        within += [f"the gap {gaps[0]['dx']} tiles ahead"] if gaps and gaps[0]["dx"] <= reach + 0.5 else []
+        within += [f"the {walls[0]['kind']} {walls[0]['dx']} tiles ahead"] if walls and walls[0]["dx"] <= reach + 0.5 else []
+        within += [f"the question block {blocks[0]['dx']} tiles ahead"] if blocks and blocks[0]["dx"] <= reach + 0.5 else []
+        parts.append(f"Until the next decision Mario covers about {reach} tiles, and a walking enemy closes about {closing}. "
                      + (f"Within one step: {'; '.join(within)}." if within else "Nothing is within one step."))
         if self._stopped >= 2:
-            parts.append(f"Mario has been stopped in place for {self._stopped} steps by something he is pressed "
-                         "against: walk_left one step, then jump_right held long.")
+            parts.append(f"Mario has been stopped in place for {self._stopped} decisions by something he is pressed "
+                         "against: walk_left, then run_right, then jump_right at 2 to 3 tiles.")
+        held = [KEY_NAMES[c] for c in self._held]
+        if KEY["jump"] in self._held:
+            parts.append("The jump key is held: it must be let go (run_right or wait) before Mario can jump again.")
         parts.append(f"Lives {st.get('lives')}, coins {st.get('coins')}, time {st.get('time')}, score {st.get('score')}.")
         terminal = bool(st.get("ending")) or (bool(st.get("dead")) and (st.get("lives") or 0) <= 0)
         fields = {k: st.get(k) for k in ("x", "y", "level_x", "on_ground", "dead", "xvel", "lives", "coins", "time", "score", "world")}
         fields["enemies"] = en
         fields["behind"] = st.get("behind") or []
         fields["gaps"] = gaps
-        fields["walls"] = [{**w, "hold": hold_for(w["height"])} for w in walls]
+        fields["walls"] = walls
         fields["blocks"] = blocks
         fields["stopped_steps"] = self._stopped
         fields["step_reach_tiles"] = reach
         fields["within_one_step"] = within
-        return {"ok": True, "text": " ".join(parts), "fields": fields, "candidates": {}, "terminal": terminal}
+        fields["keys_held"] = held
+        return {"ok": True, "text": " ".join(parts), "fields": fields, "candidates": {}, "terminal": terminal, "realtime": True}
 
 
 def build(game: Game):
@@ -573,10 +409,6 @@ def build(game: Game):
     from mcp.types import ToolAnnotations
 
     m = MCPServer("mario", instructions=INSTRUCTIONS, log_level="WARNING")
-    Hold = Annotated[str, Field(description="How long to hold the keys.",
-                                json_schema_extra={"oneOf": [{"const": "short", "description": "about 0.15 s, a small step or hop"},
-                                                             {"const": "medium", "description": "about 0.35 s, a normal jump or stride"},
-                                                             {"const": "long", "description": "about 0.6 s, the highest jump or a long run"}]})]
 
     @m.tool(annotations=ToolAnnotations(readOnlyHint=True), description="Where Mario is and what is ahead, right now.")
     def observe() -> dict:
@@ -590,25 +422,25 @@ def reset(goal: str = "") -> dict:
     # writes (0.7) the model was refused three times mid-air at 0.40 to 0.59 and the run stopped.
     keys = {"risk": "read"}
 
-    @m.tool(description="Run to the right for a moment, and keep running until told otherwise.", meta=keys)
+    @m.tool(description="Hold right and run: Mario runs right, or keeps running, until the keys change.", meta=keys)
     def run_right() -> dict:
-        return game.act("run_right", "medium")
+        return game.act("run_right")
 
-    @m.tool(description="Jump while running right, over an enemy, a gap or a wall ahead; the run continues after the jump.", meta=keys)
-    def jump_right(hold: Hold) -> dict:
-        return game.act("jump_right", hold)
+    @m.tool(description="Hold right, run and jump: Mario leaves the ground if he is on it, and the longer jump stays held the higher he goes.", meta=keys)
+    def jump_right() -> dict:
+        return game.act("jump_right")
 
-    @m.tool(description="Jump straight up, without moving.", meta=keys)
-    def jump(hold: Hold) -> dict:
-        return game.act("jump", hold)
+    @m.tool(description="Hold jump alone: a jump straight up, standing.", meta=keys)
+    def jump() -> dict:
+        return game.act("jump")
 
-    @m.tool(description="Walk to the left, to back away from something.", meta=keys)
-    def walk_left(hold: Hold) -> dict:
-        return game.act("walk_left", hold)
+    @m.tool(description="Hold left: Mario walks left, to back away from something.", meta=keys)
+    def walk_left() -> dict:
+        return game.act("walk_left")
 
-    @m.tool(annotations=ToolAnnotations(readOnlyHint=True), description="Let go of every key, stand still for a quarter second and look again.")
+    @m.tool(annotations=ToolAnnotations(readOnlyHint=True), description="Let go of every key: Mario stops, and a held jump is released.")
     def wait() -> dict:
-        return game.wait()
+        return game.act("wait")
 
     return m
 

From c6c6769ce4155eb5bd3a3a6ebab95131c4d2cc60 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:29:03 -0700
Subject: [PATCH 12/26] mario: the state says what the facts call for now

One sentence per state, computed from the measured facts and said outright: the enemy walking at
Mario is a tile away, jump standing; the pipe's take-off point is here, jump_right and hold it
three decisions; stopped at a tall pipe, walk_left two decisions first; nothing within reach, run.
Also the block row overhead and when a walking enemy arrives. The environment executes none of
it; the model reads it and chooses (a System One model acts on the state, not on a paragraph).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 39 ++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 76d6e25..ad9b45e 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -321,6 +321,38 @@ async def go():
         d["text"] = f"{name}: holding {held}. " + d["text"]
         return d
 
+    def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks: list, overhead: list) -> str:
+        """What the measured facts call for in this state, in one sentence. The environment
+        executes nothing here; the model reads it and chooses."""
+        held = KEY["jump"] in self._held
+        on_ground = st.get("on_ground")
+        fast = abs(st.get("xvel") or 0) >= 3
+        if not on_ground:
+            return "in the air, run_right keeps the run and lets the jump key go for the next jump." if held else "in the air, run_right keeps the run."
+        near = en[0] if en else None
+        if near and near.get("dir") == "toward" and abs(near["dy"]) < 1 and near["dx"] <= 6 and (overhead or not fast):
+            if near["dx"] <= 1.3:
+                return "the enemy is a tile away: jump now, standing."
+            return "an enemy walks at Mario" + (" under blocks" if overhead else "") + ": wait (stand still) and jump when it is a tile away."
+        if walls and walls[0]["height"] >= TALL and walls[0]["dx"] <= 6:
+            w = walls[0]
+            if w["dx"] <= 0.3 and not fast:
+                return "stopped at a tall pipe: walk_left for two decisions, then run_right, then jump_right at 2 to 3 tiles."
+            if fast and 2.0 <= w["dx"] <= 3.2:
+                return "jump_right now, and keep it held for three decisions: the pipe's take-off point is here."
+            if not fast and w["dx"] <= 3.2:
+                return "too slow for the pipe from here: walk_left for two decisions, then run_right and jump_right at 2 to 3 tiles."
+            return "run_right toward the pipe; jump_right when it is 2 to 3 tiles ahead."
+        if gaps and gaps[0]["dx"] <= reach + 0.5:
+            return "jump_right now, from the gap's edge, at a run." if fast else "too slow for the gap: walk_left two decisions, then run_right and jump_right at its edge."
+        if walls and walls[0]["dx"] <= reach + 0.5:
+            return "jump_right now over the wall ahead."
+        if near and near["dx"] <= reach + 0.5 and abs(near["dy"]) < 1:
+            return "jump_right now over the enemy at a run." if fast else "wait, and jump when the enemy is a tile away."
+        if blocks and blocks[0]["dx"] <= reach + 0.5:
+            return "jump_right now, under the question block, for the coin."
+        return "nothing within reach: run_right."
+
     def _describe(self, st: dict) -> dict:
         if not st.get("ready"):
             return {"ok": True, "text": "The game is loading.", "fields": {"ready": False}, "candidates": {}, "terminal": False, "realtime": True}
@@ -341,7 +373,8 @@ def _describe(self, st: dict) -> dict:
         if en:
             e = en[0]
             where = "at Mario's height" if abs(e["dy"]) < 1 else ("above" if e["dy"] > 0 else "below")
-            parts.append(f"Nearest enemy: {e['kind']} {e['dx']} tiles ahead, {where}, walking {'toward Mario' if e.get('dir') == 'toward' else 'away'}."
+            arrives = f", at Mario in about {max(1, round(e['dx'] / 0.6))} decisions if he stands still" if e.get("dir") == "toward" and abs(e["dy"]) < 1 else ""
+            parts.append(f"Nearest enemy: {e['kind']} {e['dx']} tiles ahead, {where}, walking {'toward Mario' if e.get('dir') == 'toward' else 'away'}{arrives}."
                          + (f" {len(en) - 1} more behind it." if len(en) > 1 else ""))
         else:
             parts.append("No enemy within 12 tiles ahead.")
@@ -360,6 +393,9 @@ def _describe(self, st: dict) -> dict:
             parts.append(f"Wall ahead: {w['kind']} {w['dx']} tiles ahead, {w['height']} tiles tall; it takes {need}.")
         else:
             parts.append("No pipe or wall within 8 tiles.")
+        overhead = [o for o in st.get("overhead") or [] if o["dx"] <= 6]
+        if overhead:
+            parts.append(f"Blocks overhead {overhead[0]['dx']} tiles ahead: a running jump there hits them and drops Mario straight down.")
         blocks = st.get("blocks") or []
         if blocks:
             b = blocks[0]
@@ -381,6 +417,7 @@ def _describe(self, st: dict) -> dict:
         within += [f"the question block {blocks[0]['dx']} tiles ahead"] if blocks and blocks[0]["dx"] <= reach + 0.5 else []
         parts.append(f"Until the next decision Mario covers about {reach} tiles, and a walking enemy closes about {closing}. "
                      + (f"Within one step: {'; '.join(within)}." if within else "Nothing is within one step."))
+        parts.append("Now: " + self._now(st, reach, en, gaps, walls, blocks, overhead))
         if self._stopped >= 2:
             parts.append(f"Mario has been stopped in place for {self._stopped} decisions by something he is pressed "
                          "against: walk_left, then run_right, then jump_right at 2 to 3 tiles.")

From 9e389fa46f526de46b60b57493844b73d76d219e Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:33:15 -0700
Subject: [PATCH 13/26] mario: the Now line speaks for the moment the decision
 lands, and the enemy jump is measured

A decision arrives about a quarter second after the state it reads; at a run that is 2.5 tiles,
so every distance in the Now line is projected by that much. Measured on the first Goomba: a
running jump started 3 to 4 tiles before it survives every time and stomps it for 300 at 4; from
5 to 9 tiles it hits the block row and drops onto it, every time. The wait-and-let-under advice
there is gone; the prompt and the Now line say the running jump at 3 to 4 tiles.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 55 +++++++++++++++++----------
 1 file changed, 35 insertions(+), 20 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index ad9b45e..fd7150c 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -322,34 +322,49 @@ async def go():
         return d
 
     def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks: list, overhead: list) -> str:
-        """What the measured facts call for in this state, in one sentence. The environment
-        executes nothing here; the model reads it and chooses."""
+        """What the measured facts call for, said for the moment the decision will land: a
+        decision arrives about a quarter second after this state, and at a run Mario covers
+        2.5 tiles in that time, so every distance here is projected by that much. Measured on
+        the live game: a running jump started 3 to 4 tiles before the first Goomba survives
+        every time (5 to 9 tiles hits the block row and drops onto it); a 4-tile pipe is cleared
+        by a long jump taken 2 to 3 tiles before it at speed; a gap by a running jump from its
+        edge. The environment executes nothing here; the model reads it and chooses."""
         held = KEY["jump"] in self._held
         on_ground = st.get("on_ground")
-        fast = abs(st.get("xvel") or 0) >= 3
+        xv = abs(st.get("xvel") or 0)
+        fast = xv >= 3
+        lag = round(xv * 60 * 0.25 / (8 * 4), 1)          # tiles covered before the decision lands
         if not on_ground:
             return "in the air, run_right keeps the run and lets the jump key go for the next jump." if held else "in the air, run_right keeps the run."
-        near = en[0] if en else None
-        if near and near.get("dir") == "toward" and abs(near["dy"]) < 1 and near["dx"] <= 6 and (overhead or not fast):
-            if near["dx"] <= 1.3:
-                return "the enemy is a tile away: jump now, standing."
-            return "an enemy walks at Mario" + (" under blocks" if overhead else "") + ": wait (stand still) and jump when it is a tile away."
-        if walls and walls[0]["height"] >= TALL and walls[0]["dx"] <= 6:
-            w = walls[0]
+        near = next((e for e in en if abs(e["dy"]) < 1), None)
+        near_next = (near["dx"] - lag - (0.5 if near.get("dir") == "toward" else 0)) if near else None
+        if walls and walls[0]["height"] >= TALL and walls[0]["dx"] <= 8:
+            w = walls[0]; w_next = w["dx"] - lag
             if w["dx"] <= 0.3 and not fast:
                 return "stopped at a tall pipe: walk_left for two decisions, then run_right, then jump_right at 2 to 3 tiles."
-            if fast and 2.0 <= w["dx"] <= 3.2:
-                return "jump_right now, and keep it held for three decisions: the pipe's take-off point is here."
-            if not fast and w["dx"] <= 3.2:
+            if not fast and w["dx"] <= 4:
                 return "too slow for the pipe from here: walk_left for two decisions, then run_right and jump_right at 2 to 3 tiles."
-            return "run_right toward the pipe; jump_right when it is 2 to 3 tiles ahead."
-        if gaps and gaps[0]["dx"] <= reach + 0.5:
-            return "jump_right now, from the gap's edge, at a run." if fast else "too slow for the gap: walk_left two decisions, then run_right and jump_right at its edge."
-        if walls and walls[0]["dx"] <= reach + 0.5:
+            if fast and 1.8 <= w_next <= 3.4:
+                return "jump_right now, and keep it held for three decisions: the pipe's take-off point is here."
+            if fast and w_next < 1.8:
+                return "jump_right now and hold it three decisions."
+            return "run_right toward the pipe; jump_right when it is about 5 tiles ahead at this speed."
+        if near is not None and near["dx"] <= 9:
+            if fast:
+                if near_next <= 4.5:
+                    return "jump_right now over the enemy: at this speed the take-off comes 3 to 4 tiles before it."
+                return "run_right; jump_right when the enemy is about 7 tiles ahead at this speed."
+            if near.get("dir") == "toward":
+                return "jump now, standing: it is about to reach Mario." if near_next <= 1.5 else "wait, standing still; jump when it is 2 tiles away."
+            return "run_right after it; jump_right when it is about 7 tiles ahead at a run."
+        if gaps and gaps[0]["dx"] <= 8:
+            g_next = gaps[0]["dx"] - lag
+            if fast:
+                return "jump_right now, from the gap's edge, at a run." if g_next <= 2.0 else "run_right to the gap; jump_right when its edge is about 4 tiles ahead at this speed."
+            return "too slow for the gap: walk_left two decisions, then run_right and jump_right when its edge is 4 tiles ahead."
+        if walls and walls[0]["dx"] - lag <= 1.5:
             return "jump_right now over the wall ahead."
-        if near and near["dx"] <= reach + 0.5 and abs(near["dy"]) < 1:
-            return "jump_right now over the enemy at a run." if fast else "wait, and jump when the enemy is a tile away."
-        if blocks and blocks[0]["dx"] <= reach + 0.5:
+        if blocks and blocks[0]["dx"] - lag <= 1.8:
             return "jump_right now, under the question block, for the coin."
         return "nothing within reach: run_right."
 

From 9cdb6d86c29f6c998039f6977a07b8331bb2fb02 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:37:26 -0700
Subject: [PATCH 14/26] mario: the Now line keeps the jump held while rising
 and lets an enemy outrank a pipe

Recorded: after 'jump_right now' at a tall pipe the next line said the run frees the jump key,
so the jump was let go at 0.3 s, peaked at 3.9 tiles and hit the 4-tile pipe; then 'stopped at a
tall pipe: walk_left' walked Mario into the pair behind him. The line now says to keep the jump
held while rising, treats an enemy within four tiles as the thing that matters, and asks for the
enemy jump at the measured window.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index fd7150c..3e673f7 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -106,7 +106,7 @@
   function amt(k){ return d[k] && d[k].amount !== undefined ? d[k].amount : null; }
   return {ready: true, x: tiles(p.left), y: tiles(ground - p.bottom), level_x: tiles(p.left + (window.__s1scroll || 0)),
           dying: !!p.dying,
-          screen_tiles: tiles(sr - sl), xvel: Math.round((p.xvel || 0) * 10) / 10, on_ground: !!p.resting, dead: !!p.dead,
+          screen_tiles: tiles(sr - sl), xvel: Math.round((p.xvel || 0) * 10) / 10, yvel: Math.round((p.yvel || 0) * 10) / 10, on_ground: !!p.resting, dead: !!p.dead,
           power: p.power || 1, enemies: enemies.slice(0, 3), behind: behind.slice(0, 2), gaps: gaps.slice(0, 2), walls: walls.slice(0, 2), blocks: blocks.slice(0, 2), overhead: overhead.slice(0, 4),
           lives: amt('lives'), time: amt('time'), score: amt('score'), coins: amt('coins'), world: amt('world'), paused: !!window.paused,
           ending: !!(window.map && map.ending)};
@@ -334,10 +334,21 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
         xv = abs(st.get("xvel") or 0)
         fast = xv >= 3
         lag = round(xv * 60 * 0.25 / (8 * 4), 1)          # tiles covered before the decision lands
+        rising = (st.get("yvel") or 0) < 0
         if not on_ground:
-            return "in the air, run_right keeps the run and lets the jump key go for the next jump." if held else "in the air, run_right keeps the run."
+            if held and rising:
+                return "keep jump_right held: Mario is still rising, and the jump grows as long as it is held."
+            return "falling: run_right keeps the run and frees the jump key for the next jump." if held else "in the air: run_right keeps the run."
         near = next((e for e in en if abs(e["dy"]) < 1), None)
         near_next = (near["dx"] - lag - (0.5 if near.get("dir") == "toward" else 0)) if near else None
+        back = next((b for b in st.get("behind") or [] if b.get("dir") == "toward" and abs(b["dy"]) < 1 and b["dx"] <= 2.5), None)
+        # an enemy about to touch him outranks everything: it is the lethal thing
+        if near is not None and near["dx"] <= 4 and not fast:
+            if near.get("dir") == "toward":
+                return "jump now, standing: the enemy is about to reach Mario." if near_next <= 1.5 else "wait, standing still; jump when it is 2 tiles away."
+            return "walk_left one decision to make room, then run_right and jump_right when it is about 7 tiles ahead."
+        if back is not None and not fast:
+            return "jump now, standing: an enemy at Mario's back is about to reach him."
         if walls and walls[0]["height"] >= TALL and walls[0]["dx"] <= 8:
             w = walls[0]; w_next = w["dx"] - lag
             if w["dx"] <= 0.3 and not fast:
@@ -351,9 +362,9 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
             return "run_right toward the pipe; jump_right when it is about 5 tiles ahead at this speed."
         if near is not None and near["dx"] <= 9:
             if fast:
-                if near_next <= 4.5:
+                if near_next <= 3.6:
                     return "jump_right now over the enemy: at this speed the take-off comes 3 to 4 tiles before it."
-                return "run_right; jump_right when the enemy is about 7 tiles ahead at this speed."
+                return "run_right; jump_right when the enemy is about 6 tiles ahead at this speed."
             if near.get("dir") == "toward":
                 return "jump now, standing: it is about to reach Mario." if near_next <= 1.5 else "wait, standing still; jump when it is 2 tiles away."
             return "run_right after it; jump_right when it is about 7 tiles ahead at a run."

From a863b8c085dea2c94379fa6eb154d13e71b7cc80 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:42:16 -0700
Subject: [PATCH 15/26] mario: from standing the arriving enemy is jumped with
 jump_right, and a ledge enemy is waited for

Measured: from standing, jump_right as the enemy arrives survives eight of eight between 1 and
2.5 tiles, and it is the action the model follows (the standing jump tool it did not). Recorded
five times near the first ledge: the Goomba on it walks off its edge and drops onto a Mario
running under; the state now says to wait for it to come down and jump it at Mario's height.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 3e673f7..f64415a 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -342,13 +342,19 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
         near = next((e for e in en if abs(e["dy"]) < 1), None)
         near_next = (near["dx"] - lag - (0.5 if near.get("dir") == "toward" else 0)) if near else None
         back = next((b for b in st.get("behind") or [] if b.get("dir") == "toward" and abs(b["dy"]) < 1 and b["dx"] <= 2.5), None)
-        # an enemy about to touch him outranks everything: it is the lethal thing
+        # an enemy about to touch him outranks everything: it is the lethal thing. Measured: from
+        # standing, jump_right as it arrives (1 to 2.5 tiles) survives every time
+        above = next((e for e in en if e["dy"] > 1 and e["dx"] <= 5 and e.get("dir") == "toward"), None)
         if near is not None and near["dx"] <= 4 and not fast:
             if near.get("dir") == "toward":
-                return "jump now, standing: the enemy is about to reach Mario." if near_next <= 1.5 else "wait, standing still; jump when it is 2 tiles away."
-            return "walk_left one decision to make room, then run_right and jump_right when it is about 7 tiles ahead."
+                return "jump_right now: the enemy is about to reach Mario." if near_next <= 2.2 else "wait, standing still; jump_right when it is 2 tiles away."
+            return "walk_left one decision to make room, then run_right and jump_right when it is about 6 tiles ahead."
         if back is not None and not fast:
-            return "jump now, standing: an enemy at Mario's back is about to reach him."
+            return "jump_right now: an enemy at Mario's back is about to reach him."
+        if above is not None and (near is None or near["dx"] > 6):
+            # recorded five times: the Goomba on the ledge walks off its edge and drops onto a Mario
+            # running under it
+            return "wait, standing still: the enemy above is about to drop off its ledge; jump_right when it is 2 tiles away at Mario's height."
         if walls and walls[0]["height"] >= TALL and walls[0]["dx"] <= 8:
             w = walls[0]; w_next = w["dx"] - lag
             if w["dx"] <= 0.3 and not fast:

From e72ddfe3d4778d467b88f6fb9c0fe4cb5b6af5a4 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:47:10 -0700
Subject: [PATCH 16/26] mario: jump means press jump

A jump key still held from the last jump does nothing on the ground (the game wants a release
first); recorded, four lives went to a jump that never happened. The action now lets the key go
and presses it again within the tick, the way a thumb does. Measured: a running jump started 1.5
to 2.5 tiles before an enemy survives six of six (1.0 dies), so in the open the Now line asks for
the jump from farther out; the 3-to-4 window is the block row's.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index f64415a..352cd80 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -231,6 +231,13 @@ async def _tick(self, name: str) -> None:
         from the facts the state and its instructions carry."""
         R, S, U, L = KEY["right"], KEY["sprint"], KEY["jump"], KEY["left"]
         keys = {"run_right": (R, S), "jump_right": (R, S, U), "jump": (U,), "walk_left": (L,), "wait": ()}[name]
+        if U in keys and U in self._held and await self._eval("!!player.resting"):
+            # "jump" means press jump: a key still held from the last jump would do nothing on
+            # the ground (the game wants a release first), so it is let go and pressed again,
+            # the way a thumb does. Recorded: four lives to a jump that never happened
+            await self._eval(f"keyup({U}); 'ok'")
+            self._held.discard(U)
+            await asyncio.sleep(0.04)
         await self._keys(*keys)
         await asyncio.sleep(TICK)
 
@@ -338,7 +345,7 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
         if not on_ground:
             if held and rising:
                 return "keep jump_right held: Mario is still rising, and the jump grows as long as it is held."
-            return "falling: run_right keeps the run and frees the jump key for the next jump." if held else "in the air: run_right keeps the run."
+            return "falling: run_right keeps the run; jump_right again the moment Mario lands if something is close."
         near = next((e for e in en if abs(e["dy"]) < 1), None)
         near_next = (near["dx"] - lag - (0.5 if near.get("dir") == "toward" else 0)) if near else None
         back = next((b for b in st.get("behind") or [] if b.get("dir") == "toward" and abs(b["dy"]) < 1 and b["dx"] <= 2.5), None)
@@ -368,9 +375,11 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
             return "run_right toward the pipe; jump_right when it is about 5 tiles ahead at this speed."
         if near is not None and near["dx"] <= 9:
             if fast:
-                if near_next <= 3.6:
-                    return "jump_right now over the enemy: at this speed the take-off comes 3 to 4 tiles before it."
-                return "run_right; jump_right when the enemy is about 6 tiles ahead at this speed."
+                # measured: under the block row the take-off must be 3 to 4 tiles before it; in the
+                # open a running jump from farther lands past it just the same
+                if near_next <= (3.8 if overhead else 5.5):
+                    return "jump_right now over the enemy: at this speed the take-off comes a few tiles before it."
+                return "run_right; jump_right when the enemy is about 7 tiles ahead at this speed."
             if near.get("dir") == "toward":
                 return "jump now, standing: it is about to reach Mario." if near_next <= 1.5 else "wait, standing still; jump when it is 2 tiles away."
             return "run_right after it; jump_right when it is about 7 tiles ahead at a run."
@@ -454,8 +463,8 @@ def _describe(self, st: dict) -> dict:
             parts.append(f"Mario has been stopped in place for {self._stopped} decisions by something he is pressed "
                          "against: walk_left, then run_right, then jump_right at 2 to 3 tiles.")
         held = [KEY_NAMES[c] for c in self._held]
-        if KEY["jump"] in self._held:
-            parts.append("The jump key is held: it must be let go (run_right or wait) before Mario can jump again.")
+        if KEY["jump"] in self._held and not st.get("on_ground"):
+            parts.append("The jump key is held; it keeps the jump growing while Mario rises.")
         parts.append(f"Lives {st.get('lives')}, coins {st.get('coins')}, time {st.get('time')}, score {st.get('score')}.")
         terminal = bool(st.get("ending")) or (bool(st.get("dead")) and (st.get("lives") or 0) <= 0)
         fields = {k: st.get(k) for k in ("x", "y", "level_x", "on_ground", "dead", "xvel", "lives", "coins", "time", "score", "world")}

From 33a7a3499ae7d6cd80882a7b02b5a30fd2266008 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:51:50 -0700
Subject: [PATCH 17/26] mario: the pipe and the gap ask for full speed, and a
 follower is let under before backing off

Recorded at the fourth pipe: a jump at a jog hit its side, and the back-off line then walked
Mario into the pair behind him, four lives. The line now asks for full speed (4.5 and up, the
measured clearing speed) before the take-off, sends him back to gain it when there is room, and
when an enemy follows him to a pipe says to let it under a standing jump first. The gap line
asks for speed the same way instead of a jump from a standstill at its edge.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 352cd80..6b07628 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -357,20 +357,26 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
                 return "jump_right now: the enemy is about to reach Mario." if near_next <= 2.2 else "wait, standing still; jump_right when it is 2 tiles away."
             return "walk_left one decision to make room, then run_right and jump_right when it is about 6 tiles ahead."
         if back is not None and not fast:
-            return "jump_right now: an enemy at Mario's back is about to reach him."
+            return "jump, standing (the jump tool, not jump_right): the enemy at Mario's back passes under him."
         if above is not None and (near is None or near["dx"] > 6):
             # recorded five times: the Goomba on the ledge walks off its edge and drops onto a Mario
             # running under it
             return "wait, standing still: the enemy above is about to drop off its ledge; jump_right when it is 2 tiles away at Mario's height."
         if walls and walls[0]["height"] >= TALL and walls[0]["dx"] <= 8:
+            # measured: the pipe is cleared at near full speed (4.9 and up) with the jump held
+            # long; at a jog the apex is level with its top and the side stops him (recorded)
             w = walls[0]; w_next = w["dx"] - lag
-            if w["dx"] <= 0.3 and not fast:
-                return "stopped at a tall pipe: walk_left for two decisions, then run_right, then jump_right at 2 to 3 tiles."
-            if not fast and w["dx"] <= 4:
-                return "too slow for the pipe from here: walk_left for two decisions, then run_right and jump_right at 2 to 3 tiles."
-            if fast and 1.8 <= w_next <= 3.4:
+            full = xv >= 4.5
+            follower = next((b for b in st.get("behind") or [] if b.get("dir") == "toward" and abs(b["dy"]) < 1 and b["dx"] <= 6), None)
+            if not full and w["dx"] <= 4.5:
+                if follower is not None:
+                    return "jump, standing (the jump tool): the enemy behind passes under; then walk_left two decisions and run at the pipe."
+                return "too slow for the pipe from here: walk_left for two decisions, then run_right to full speed and jump_right at 2 to 3 tiles."
+            if not full:
+                return "run_right to full speed; jump_right when the pipe is about 5 tiles ahead and Mario is running flat out."
+            if 1.8 <= w_next <= 3.4:
                 return "jump_right now, and keep it held for three decisions: the pipe's take-off point is here."
-            if fast and w_next < 1.8:
+            if w_next < 1.8:
                 return "jump_right now and hold it three decisions."
             return "run_right toward the pipe; jump_right when it is about 5 tiles ahead at this speed."
         if near is not None and near["dx"] <= 9:
@@ -385,8 +391,10 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
             return "run_right after it; jump_right when it is about 7 tiles ahead at a run."
         if gaps and gaps[0]["dx"] <= 8:
             g_next = gaps[0]["dx"] - lag
-            if fast:
+            if xv >= 4:
                 return "jump_right now, from the gap's edge, at a run." if g_next <= 2.0 else "run_right to the gap; jump_right when its edge is about 4 tiles ahead at this speed."
+            if gaps[0]["dx"] >= 3.5:
+                return "run_right to gain speed for the gap; jump_right when its edge is about 4 tiles ahead at a run."
             return "too slow for the gap: walk_left two decisions, then run_right and jump_right when its edge is 4 tiles ahead."
         if walls and walls[0]["dx"] - lag <= 1.5:
             return "jump_right now over the wall ahead."

From 21e06faade5406b34fae9cc9a4fae45f39fee438 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:55:32 -0700
Subject: [PATCH 18/26] mario: at a gap the jump waits for a clear landing

Recorded six times: the jump across a gap lands nine tiles on, among the enemies waiting there,
and a falling Mario can do nothing. Enemies walking toward the gap come to it and fall in, so the
state says to stand at the edge until none is within ten tiles past it.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 6b07628..fd85064 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -391,6 +391,15 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
             return "run_right after it; jump_right when it is about 7 tiles ahead at a run."
         if gaps and gaps[0]["dx"] <= 8:
             g_next = gaps[0]["dx"] - lag
+            # recorded six times: the jump across lands nine tiles on, among the enemies waiting
+            # there (a pair beyond the gap, a Goomba dropping off its ledge). Ones walking toward
+            # the gap come to it and fall in; the jump waits for a clear landing
+            zone = [e for e in en if gaps[0]["dx"] + 1 <= e["dx"] <= gaps[0]["dx"] + 11]
+            if zone and any(e.get("dir") == "toward" for e in zone):
+                if xv < 1 and gaps[0]["dx"] <= 4:
+                    return "wait, standing still at the gap: the enemies beyond it are walking to it and will fall in; jump_right when none stands within 10 tiles past the edge, or when one is 2 tiles away."
+                if gaps[0]["dx"] <= 4:
+                    return "wait (let every key go) before the gap: enemies wait where the jump would land."
             if xv >= 4:
                 return "jump_right now, from the gap's edge, at a run." if g_next <= 2.0 else "run_right to the gap; jump_right when its edge is about 4 tiles ahead at this speed."
             if gaps[0]["dx"] >= 3.5:

From 08178eba0a416e12d3196084bff82b1295914418 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 01:59:32 -0700
Subject: [PATCH 19/26] mario: a ledge enemy counts in the landing zone
 whichever way it walks, and the prompt has the follower rule

Recorded five times: the Goomba on the ledge past the first gap walks off its edge whichever way
it faces when the jump is taken, so it counts in the landing zone whatever its direction. At the
fourth pipe the model walked left into its follower with 0.5 to 0.7 probability against the
state's standing-jump line: the prompt's own pipe advice said walk left. The prompt now carries
the follower case.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index fd85064..75a4c66 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -394,8 +394,10 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
             # recorded six times: the jump across lands nine tiles on, among the enemies waiting
             # there (a pair beyond the gap, a Goomba dropping off its ledge). Ones walking toward
             # the gap come to it and fall in; the jump waits for a clear landing
-            zone = [e for e in en if gaps[0]["dx"] + 1 <= e["dx"] <= gaps[0]["dx"] + 11]
-            if zone and any(e.get("dir") == "toward" for e in zone):
+            # an enemy above the landing (on the ledge past the first gap) drops off its edge
+            # whichever way it walks now, so it counts whatever its direction (recorded five times)
+            zone = [e for e in en if gaps[0]["dx"] + 1 <= e["dx"] <= gaps[0]["dx"] + 11 and (e["dy"] > 1 or e.get("dir") == "toward")]
+            if zone:
                 if xv < 1 and gaps[0]["dx"] <= 4:
                     return "wait, standing still at the gap: the enemies beyond it are walking to it and will fall in; jump_right when none stands within 10 tiles past the edge, or when one is 2 tiles away."
                 if gaps[0]["dx"] <= 4:

From 7d48c06e82422552d54c1d3e6b0e88f66eaa1be6 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 02:03:55 -0700
Subject: [PATCH 20/26] mario: the state projects by the loop's measured pace,
 and the page counts deaths again

The Now line said 'now' one decision ahead by a constant quarter second; the loop decides 3.4
times a second here and 2.2 through the test box's relay, so the environment now measures the
interval between its own actions and projects by that. The gap's landing zone counts a ledge
enemy from the gap's edge; the pipe's back-off is four decisions and a jump too close to the
pipe is refused for a fresh run-up. The page's observation parser expected the old sentence
without coins and counted no deaths.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/app/src/lib/game.js        |  4 ++--
 kits/mario/plugin/server/mario_env.py | 21 +++++++++++++++++----
 2 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/kits/mario/app/src/lib/game.js b/kits/mario/app/src/lib/game.js
index d53a40c..726907c 100644
--- a/kits/mario/app/src/lib/game.js
+++ b/kits/mario/app/src/lib/game.js
@@ -49,8 +49,8 @@ export function turnRunning(detail) {
  *  not one of its observations. */
 export function readObservation(text) {
   const t = String(text || '');
-  const m = /Lives (\d+), time (\d+), score (\d+)\./.exec(t);
-  if (m) return { lives: +m[1], time: +m[2], score: +m[3] };
+  const m = /Lives (\d+), coins (\d+), time (\d+), score (\d+)\./.exec(t);
+  if (m) return { lives: +m[1], coins: +m[2], time: +m[3], score: +m[4] };
   const d = /Mario has just died\. Lives left: (\d+)/.exec(t);
   return d ? { lives: +d[1] } : null;
 }
diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 75a4c66..322c22d 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -155,6 +155,7 @@ def __init__(self):
         self.steps = 0
         self.frames = 0
         self._stopped = 0          # consecutive runs that moved nothing
+        self._acted_at: list[float] = []   # when each action landed: the loop's own pace, measured
 
         self._lives = None
         self._restarting_until = 0.0
@@ -314,7 +315,19 @@ def _restarting(self, st: dict) -> bool:
             self._restarting_until = max(self._restarting_until, time.time() + 3.0)
         return time.time() < self._restarting_until
 
+    def lag(self) -> float:
+        """Seconds from the state a decision reads to the moment it lands, measured as the loop
+        runs: the median of the last intervals between actions, less the tick itself. The pace
+        differs by deployment (3.4 decisions a second here, 2.2 through a relay), so a constant
+        would say "now" at the wrong tile."""
+        gaps = [b - a for a, b in zip(self._acted_at[-8:], self._acted_at[-7:])]
+        if len(gaps) < 3:
+            return 0.3
+        gaps.sort()
+        return min(0.9, max(0.12, gaps[len(gaps) // 2] - TICK))
+
     def act(self, name: str) -> dict:
+        self._acted_at.append(time.time())
         async def go():
             await self._start()
             await self._tick(name)
@@ -340,7 +353,7 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
         on_ground = st.get("on_ground")
         xv = abs(st.get("xvel") or 0)
         fast = xv >= 3
-        lag = round(xv * 60 * 0.25 / (8 * 4), 1)          # tiles covered before the decision lands
+        lag = round(xv * 60 * self.lag() / (8 * 4), 1)    # tiles covered before the decision lands, at the measured pace
         rising = (st.get("yvel") or 0) < 0
         if not on_ground:
             if held and rising:
@@ -433,7 +446,7 @@ def _describe(self, st: dict) -> dict:
         if en:
             e = en[0]
             where = "at Mario's height" if abs(e["dy"]) < 1 else ("above" if e["dy"] > 0 else "below")
-            arrives = f", at Mario in about {max(1, round(e['dx'] / 0.6))} decisions if he stands still" if e.get("dir") == "toward" and abs(e["dy"]) < 1 else ""
+            arrives = f", at Mario in about {max(1, round(e['dx'] / (1.5 * (self.lag() + TICK))))} decisions if he stands still" if e.get("dir") == "toward" and abs(e["dy"]) < 1 else ""
             parts.append(f"Nearest enemy: {e['kind']} {e['dx']} tiles ahead, {where}, walking {'toward Mario' if e.get('dir') == 'toward' else 'away'}{arrives}."
                          + (f" {len(en) - 1} more behind it." if len(en) > 1 else ""))
         else:
@@ -467,9 +480,9 @@ def _describe(self, st: dict) -> dict:
         # to 7.8 tiles a step (11.5 -> 6 -> 1.3; 9.8 -> 2), a standing wall about 4; the hold, the
         # model's answer and the enemy's own walk all fit in one step, and an enemy 2 tiles away
         # at a run is already too close to jump, so it is named a step earlier than it arrives
-        # measured: a decision lands about every 0.35 s; at a full run (9 tiles a second) that is
+        # at the loop's measured pace: at a full run (9 tiles a second) a third of a second is
         # 3 tiles, and a walking enemy adds about half a tile of its own
-        reach = round(max(0.5, abs(st.get("xvel") or 0) * 60 * 0.35 / (8 * 4)), 1)
+        reach = round(max(0.5, abs(st.get("xvel") or 0) * 60 * (self.lag() + TICK) / (8 * 4)), 1)
         closing = round(reach + 0.6, 1)
         within = [f"the {en[0]['kind']} {en[0]['dx']} tiles ahead"] if en and en[0]["dx"] <= closing + 2.5 else []
         within += [f"the gap {gaps[0]['dx']} tiles ahead"] if gaps and gaps[0]["dx"] <= reach + 0.5 else []

From 431770ea81e3abe70b3f2b5ff89f23b8d5625671 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 02:05:11 -0700
Subject: [PATCH 21/26] mario: the kit prompt carries every measured rule

Three earlier edits to this prompt never landed (a heredoc escaping error in the edit script
raised before the write), so the attempts since read the first facts prompt while the Now line
carried the tactics. The prompt now states them all: the enemy take-off window, the standing
jump_right as one arrives, the ledge enemy, the pipe's speed and back-off, the follower, the gap's
landing zone.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/kit.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kits/mario/kit.json b/kits/mario/kit.json
index 5278677..58e7eb3 100644
--- a/kits/mario/kit.json
+++ b/kits/mario/kit.json
@@ -20,7 +20,7 @@
     ],
     "plugin": "plugin",
     "mcp_servers": [],
-    "system_prompt": "You play a side-scrolling platform game as Mario, deciding several times a second. Each action sets the keys for the next moment and they stay set until you change them: run_right holds right and run; jump_right holds right, run and jump; jump holds jump alone; walk_left holds left; wait lets every key go. Keep moving right.\n\nFacts, measured on this game: a decision lands about every third of a second, and at a full run Mario covers about 3 tiles between decisions. A jump held for one decision clears 3 tiles, for two decisions 4 tiles; the jump key must be let go (run_right or wait) before Mario can jump again. A running jump lands about 9 tiles on. A pipe 4 tiles tall is cleared only from a run, leaving the ground 2 to 3 tiles before it with the jump held for three decisions; from against it, or from standing, it is never cleared, so if Mario is stopped at one, walk_left for two decisions, then run_right, then jump_right at 2 to 3 tiles. A gap is crossed by a running jump from its edge; a standing jump falls in. An enemy walking at Mario is safest let under a standing jump: wait until it is about one tile away, then jump; a running jump taken with it 2 tiles away hits it. Under a row of blocks a running jump hits the blocks and drops onto whatever is below, so let the first enemy under a standing jump. A question block is hit from below by a jump started 1 to 1.5 tiles before it at a run, and pays a coin. Enemies behind Mario are outrun.\n\nWhen Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left.",
+    "system_prompt": "You play a side-scrolling platform game as Mario, deciding several times a second. Each action sets the keys for the next moment and they stay set until you change them: run_right holds right and run; jump_right holds right, run and jump; jump holds jump alone; walk_left holds left; wait lets every key go. Keep moving right. The state ends with a line beginning \"Now:\" that says what the measured facts call for at this moment; follow it.\n\nFacts, measured on this game: a decision lands a fraction of a second after the state you read, and at a full run Mario covers 2 to 3 tiles in that time. A jump held for one decision clears 3 tiles, for two decisions 4 tiles; jump_right pressed again on the ground is a new jump. A running jump lands about 9 tiles on. An enemy is jumped at a run with the take-off 1.5 to 4 tiles before it; earlier, under a row of blocks, the jump hits the blocks and drops Mario onto it. An enemy walking at a standing Mario is jumped with jump_right when it is 1 to 2.5 tiles away. An enemy on a ledge above walks off its edge and drops onto whoever runs under it: wait for it to come down, then jump_right over it. A pipe 4 tiles tall is cleared only at a full run, leaving the ground 2 to 3 tiles before it with the jump held for three decisions; from standing or at a jog it is never cleared, so if Mario is stopped at one, walk_left for four decisions, then run_right, then jump_right; but if an enemy is walking at his back, walking left meets it: stand and take jump (the standing jump) when it is 2 tiles behind him, it passes under, and only then walk_left. A gap is crossed by a running jump from its edge; a standing jump falls in; enemies waiting where the jump would land walk to the gap and fall in if Mario stands at the edge. A question block pays a coin when hit from below by a jump started 1 to 1.5 tiles before it at a run.\n\nWhen Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left.",
     "max_step": 1200,
     "$comment": "system_prompt carries the measured facts of this game; the environment executes key states and times nothing. max_step: a decision every third of a second, the level takes a few hundred, and a death costs the way back."
   },

From e093ecb24d482e718e4bb53e4873d218aa326e7d Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 02:07:34 -0700
Subject: [PATCH 22/26] mario: in the air, walk_left brakes the landing short
 of a gap or an enemy

Measured: right kept through a running jump's descent lands 9.4 tiles on and slides 2 more;
left held brakes it to 6.8 and lands Mario stopped. Recorded five times: the jump over the
fourth pipe landed a tile before the first gap and the run carried him in before a decision
could land. The in-air line now says to brake when a gap or an enemy sits where he would land.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 322c22d..d2db582 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -358,7 +358,15 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
         if not on_ground:
             if held and rising:
                 return "keep jump_right held: Mario is still rising, and the jump grows as long as it is held."
-            return "falling: run_right keeps the run; jump_right again the moment Mario lands if something is close."
+            # measured: right kept through the descent lands 9.4 tiles on and slides 2 more; left
+            # held brakes the flight to 6.8 tiles and lands him stopped. Recorded five times: the
+            # jump over the fourth pipe lands a tile before the first gap and the run carries him in
+            gap_close = gaps and gaps[0]["dx"] <= 4.5
+            foe_close = any(abs(e["dy"]) < 1 and e["dx"] <= 4 for e in en)
+            if fast and (gap_close or foe_close):
+                what = "the gap" if gap_close else "the enemy"
+                return f"walk_left now: in the air it brakes, and Mario lands stopped short of {what}; then jump_right from there at a run."
+            return "falling: run_right keeps the run."
         near = next((e for e in en if abs(e["dy"]) < 1), None)
         near_next = (near["dx"] - lag - (0.5 if near.get("dir") == "toward" else 0)) if near else None
         back = next((b for b in st.get("behind") or [] if b.get("dir") == "toward" and abs(b["dy"]) < 1 and b["dx"] <= 2.5), None)

From 66f087c18b136c7e029eccbd7acce081720ce3aa Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 02:08:42 -0700
Subject: [PATCH 23/26] mario: enemies are named from 16 tiles

At half a second a decision Mario covers four tiles and a Goomba walks one, so an enemy first
named at 12 tiles was 3.7 tiles away by the next state and the jump was already late (recorded
on the test box, three lives).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index d2db582..1145605 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -63,7 +63,7 @@
     if (!c.alive || c === player || c.title === undefined) return;
     if (['Coin','Mushroom','FireFlower','Star','Vine','Text','Shell','Fireball'].indexOf(c.title) >= 0) return;
     var dx = (c.left - p.right) / T, dy = (p.bottom - c.bottom) / T, back = (p.left - c.right) / T;
-    if (dx >= 0 && dx <= 12) enemies.push({kind: c.title, dx: Math.round(dx * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) < 0 ? 'toward' : 'away'});
+    if (dx >= 0 && dx <= 16) enemies.push({kind: c.title, dx: Math.round(dx * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) < 0 ? 'toward' : 'away'});
     else if (back >= 0 && back <= 8) behind.push({kind: c.title, dx: Math.round(back * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) > 0 ? 'toward' : 'away'});
   });
   var floors = (window.solids || []).filter(function(s){ return s.alive && (s.title === 'Floor' || s.title === 'Stone') && s.top >= p.bottom - 4; });
@@ -458,7 +458,7 @@ def _describe(self, st: dict) -> dict:
             parts.append(f"Nearest enemy: {e['kind']} {e['dx']} tiles ahead, {where}, walking {'toward Mario' if e.get('dir') == 'toward' else 'away'}{arrives}."
                          + (f" {len(en) - 1} more behind it." if len(en) > 1 else ""))
         else:
-            parts.append("No enemy within 12 tiles ahead.")
+            parts.append("No enemy within 16 tiles ahead.")
         back = st.get("behind") or []
         if back:
             b = back[0]

From cd5d88ff10aa273b1a4832ea606a71b9b132e2eb Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 02:11:46 -0700
Subject: [PATCH 24/26] mario: the gap is named from 14 tiles and every jump
 goes before the next state is past its window

Recorded: at full speed one decision covered eight tiles, the gap went from 9.5 tiles ahead to
1.5 in one step, and a wait at that point slid Mario in. The gap line starts at 14 tiles, the
stop starts while there is room, and a jump too close to stop is taken with the air brake.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/plugin/server/mario_env.py | 38 ++++++++++++++++-----------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 1145605..817dacd 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -403,31 +403,37 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
         if near is not None and near["dx"] <= 9:
             if fast:
                 # measured: under the block row the take-off must be 3 to 4 tiles before it; in the
-                # open a running jump from farther lands past it just the same
-                if near_next <= (3.8 if overhead else 5.5):
+                # open a running jump from farther lands past it just the same. The jump goes when
+                # the next state would already be past the window at this pace
+                if near_next <= (3.8 if overhead else 5.5) or near_next - lag <= 1.5:
                     return "jump_right now over the enemy: at this speed the take-off comes a few tiles before it."
-                return "run_right; jump_right when the enemy is about 7 tiles ahead at this speed."
+                return "run_right; jump_right the moment the enemy comes within reach."
             if near.get("dir") == "toward":
                 return "jump now, standing: it is about to reach Mario." if near_next <= 1.5 else "wait, standing still; jump when it is 2 tiles away."
             return "run_right after it; jump_right when it is about 7 tiles ahead at a run."
-        if gaps and gaps[0]["dx"] <= 8:
-            g_next = gaps[0]["dx"] - lag
+        if gaps and gaps[0]["dx"] <= 14:
+            g = gaps[0]["dx"]; g_next = g - lag
             # recorded six times: the jump across lands nine tiles on, among the enemies waiting
             # there (a pair beyond the gap, a Goomba dropping off its ledge). Ones walking toward
-            # the gap come to it and fall in; the jump waits for a clear landing
-            # an enemy above the landing (on the ledge past the first gap) drops off its edge
-            # whichever way it walks now, so it counts whatever its direction (recorded five times)
-            zone = [e for e in en if gaps[0]["dx"] + 1 <= e["dx"] <= gaps[0]["dx"] + 11 and (e["dy"] > 1 or e.get("dir") == "toward")]
+            # the gap come to it and fall in; the jump waits for a clear landing. And at full
+            # speed one decision covers up to eight tiles, so the stop must start early (a run
+            # needs about four tiles to stop) and the jump goes when the next state would be past
+            # its window
+            zone = [e for e in en if (g - 1 <= e["dx"] <= g + 11 and e["dy"] > 1)
+                    or (g + 1 <= e["dx"] <= g + 11 and abs(e["dy"]) < 1 and e.get("dir") == "toward")]
             if zone:
-                if xv < 1 and gaps[0]["dx"] <= 4:
+                if xv < 1 and g <= 4:
                     return "wait, standing still at the gap: the enemies beyond it are walking to it and will fall in; jump_right when none stands within 10 tiles past the edge, or when one is 2 tiles away."
-                if gaps[0]["dx"] <= 4:
-                    return "wait (let every key go) before the gap: enemies wait where the jump would land."
+                if fast and g_next <= 1.5:
+                    return "jump_right now: too close to the gap to stop; walk_left in the air to land short."
+                if xv >= 2:
+                    return "walk_left now to brake to a stop before the gap: enemies wait where the jump would land."
+                return "wait (let every key go) before the gap: enemies wait where the jump would land."
             if xv >= 4:
-                return "jump_right now, from the gap's edge, at a run." if g_next <= 2.0 else "run_right to the gap; jump_right when its edge is about 4 tiles ahead at this speed."
-            if gaps[0]["dx"] >= 3.5:
-                return "run_right to gain speed for the gap; jump_right when its edge is about 4 tiles ahead at a run."
-            return "too slow for the gap: walk_left two decisions, then run_right and jump_right when its edge is 4 tiles ahead."
+                return "jump_right now, from the gap's edge, at a run." if g_next <= lag + 2.5 else "run_right to the gap; jump_right the moment its edge comes within reach."
+            if g >= 3.5:
+                return "run_right to gain speed for the gap; jump_right the moment its edge comes within reach."
+            return "too slow for the gap: walk_left two decisions, then run_right and jump_right at its edge."
         if walls and walls[0]["dx"] - lag <= 1.5:
             return "jump_right now over the wall ahead."
         if blocks and blocks[0]["dx"] - lag <= 1.8:

From c6dca127dedbde7f6dcbb812aecb24eda4312ccf Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 02:46:04 -0700
Subject: [PATCH 25/26] mario: the ground is a profile, a jump held in the air
 goes again on landing, and the nearest thing ahead decides

Recorded on attempt 33 and reproduced nine times in a row by a player that obeys the
state's own Now line: the jump over the fourth pipe comes down a tile before the
first gap and no decision could arrive in time, a mid-air brake dropped him in from
0.8 tiles, the floor read from his feet vanished once he was below its top (the
gap 12 tiles wide), and a gap five tiles on outranked the one-tile step he was
pressed against until the clock ran out. Now the ground ahead is read from Mario's
level as a profile (pits, drops, steps), a jump held in the air is pressed again the
moment he lands (any later action cancels it), an action sets the keys and returns
(no tick), the nearest thing ahead decides the Now line, a level change is the
level cleared, and the first Goomba's take-off is taken in its window or given up
for the stop and the standing jump. The Now-line player at a 0.2 s delay clears 1-1
in 50 game seconds with one death.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/kit.json                   |   2 +-
 kits/mario/plugin/plugin.json         |   2 +-
 kits/mario/plugin/server/mario_env.py | 269 ++++++++++++++++++--------
 3 files changed, 190 insertions(+), 83 deletions(-)

diff --git a/kits/mario/kit.json b/kits/mario/kit.json
index 58e7eb3..ade1bfb 100644
--- a/kits/mario/kit.json
+++ b/kits/mario/kit.json
@@ -20,7 +20,7 @@
     ],
     "plugin": "plugin",
     "mcp_servers": [],
-    "system_prompt": "You play a side-scrolling platform game as Mario, deciding several times a second. Each action sets the keys for the next moment and they stay set until you change them: run_right holds right and run; jump_right holds right, run and jump; jump holds jump alone; walk_left holds left; wait lets every key go. Keep moving right. The state ends with a line beginning \"Now:\" that says what the measured facts call for at this moment; follow it.\n\nFacts, measured on this game: a decision lands a fraction of a second after the state you read, and at a full run Mario covers 2 to 3 tiles in that time. A jump held for one decision clears 3 tiles, for two decisions 4 tiles; jump_right pressed again on the ground is a new jump. A running jump lands about 9 tiles on. An enemy is jumped at a run with the take-off 1.5 to 4 tiles before it; earlier, under a row of blocks, the jump hits the blocks and drops Mario onto it. An enemy walking at a standing Mario is jumped with jump_right when it is 1 to 2.5 tiles away. An enemy on a ledge above walks off its edge and drops onto whoever runs under it: wait for it to come down, then jump_right over it. A pipe 4 tiles tall is cleared only at a full run, leaving the ground 2 to 3 tiles before it with the jump held for three decisions; from standing or at a jog it is never cleared, so if Mario is stopped at one, walk_left for four decisions, then run_right, then jump_right; but if an enemy is walking at his back, walking left meets it: stand and take jump (the standing jump) when it is 2 tiles behind him, it passes under, and only then walk_left. A gap is crossed by a running jump from its edge; a standing jump falls in; enemies waiting where the jump would land walk to the gap and fall in if Mario stands at the edge. A question block pays a coin when hit from below by a jump started 1 to 1.5 tiles before it at a run.\n\nWhen Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left.",
+    "system_prompt": "You play a side-scrolling platform game as Mario, deciding several times a second. Each action sets the keys for the next moment and they stay set until you change them: run_right holds right and run; jump_right holds right, run and jump, and a jump held in the air goes again the moment Mario lands, so holding it hops him along; jump holds jump alone; walk_left holds left; wait lets every key go. Keep moving right. The state ends with a line beginning \"Now:\" that says what the measured facts call for at this moment; follow it.\n\nFacts, measured on this game: a decision lands a fraction of a second after the state you read, and at a full run Mario covers 2 to 3 tiles in that time. A jump held for one decision clears 3 tiles, for two decisions 4 tiles; jump_right pressed again on the ground is a new jump, and held through a landing it is a new jump at once. A running jump lands about 9 tiles on. An enemy is jumped at a run with the take-off 1.5 to 4 tiles before it; under a row of blocks an earlier jump hits the blocks and drops Mario onto it, so when that take-off cannot be hit, stop with walk_left and jump_right when it is 1 to 2.5 tiles away, which always works. An enemy walking at a standing Mario is jumped with jump_right when it is 1 to 2.5 tiles away. An enemy on a ledge above walks off its edge and drops onto whoever runs under it: wait for it to come down, then jump_right over it. A pipe 4 tiles tall is cleared only at a full run, leaving the ground 2 to 3 tiles before it with the jump held for three decisions; from standing or at a jog it is never cleared, so if Mario is stopped at one, walk_left for four decisions, then run_right, then jump_right; but if an enemy is walking at his back, walking left meets it: stand and take jump (the standing jump) when it is 2 tiles behind him, it passes under, and only then walk_left. A step one tile tall is hopped with jump_right; a stair is a hop per step. Where the ground drops away ahead, jump_right from the edge lands past the drop, and walking off the edge lands in a slot with no way out. A gap is crossed by a running jump from its edge, and a jump still in the air with a gap coming is kept held so the next hop goes the moment Mario lands; a standing jump falls in; enemies waiting where the jump would land walk to the gap and fall in if Mario stands at the edge. A question block pays a coin when hit from below by a jump started 1 to 1.5 tiles before it at a run.\n\nWhen Mario has just died, wait. Finish when the level is cleared. Escalate when Mario has no lives left.",
     "max_step": 1200,
     "$comment": "system_prompt carries the measured facts of this game; the environment executes key states and times nothing. max_step: a decision every third of a second, the level takes a few hundred, and a death costs the way back."
   },
diff --git a/kits/mario/plugin/plugin.json b/kits/mario/plugin/plugin.json
index 0e019c6..d7c8879 100644
--- a/kits/mario/plugin/plugin.json
+++ b/kits/mario/plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "mario-env",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Full Screen Mario as an environment for the System One base: the game's state as literal text each step, the keys it listens to as actions, and the browser's frame for the page to show.",
   "homepage": "https://github.com/HarnessRouter/starter-kit",
   "license": "SEE LICENSE IN ../LICENSE.md"
diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index 817dacd..a1d7ef6 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -28,14 +28,14 @@
 
 GAME_URL = os.environ.get("MARIO_URL", "https://supermarioplay.com/game/mario.html?v=1.0.1")
 TILE = 8                      # game units per tile; the game draws a tile as 8 * unitsize px
-TICK = 0.10                   # an action sets the keys and holds them this long; they stay set until the next
+# an action sets the keys and returns; they stay set until the next action changes them
 KEY = {"left": 37, "right": 39, "jump": 38, "down": 40, "sprint": 16}
 KEY_NAMES = {37: "left", 39: "right", 38: "jump", 40: "down", 16: "run"}
 ITEMS = {"Coin", "Mushroom", "FireFlower", "Star", "Vine", "Text", "Shell", "Fireball"}
 INSTRUCTIONS = ("You play a side-scrolling platform game as Mario, deciding several times a second. Each action sets "
-                "the keys for the next moment and they stay set until you change them: run_right holds right and run, "
-                "jump_right holds right, run and jump, jump holds jump alone, walk_left holds left, wait lets every "
-                "key go. The state says where Mario is, what he is doing, what is ahead and behind with distances in "
+                "the keys for the next moment and they stay set until you change them: run_right holds right and run; "
+                "jump_right holds right, run and jump, and a jump held in the air goes again the moment Mario lands, "
+                "so holding it hops him along; jump holds jump alone; walk_left holds left; wait lets every key go. The state says where Mario is, what he is doing, what is ahead and behind with distances in "
                 "tiles, and which keys are held. Keep moving right and jump over what is within one step. Finish when "
                 "the level is cleared. Escalate when Mario has no lives left.")
 TALL = 4                      # a wall this tall is cleared only at a run
@@ -53,7 +53,7 @@
   }
   var u = window.unitsize || 4, T = 8 * u, p = player, sl = gamescreen.left, sr = gamescreen.right;
   function tiles(px){ return Math.round(px / T * 10) / 10; }
-  var enemies = [], behind = [], gaps = [], walls = [], blocks = [], overhead = [];
+  var enemies = [], behind = [], gaps = [], walls = [], blocks = [], overhead = [], drops = [];
   // heights are measured from where Mario stands: his feet on the ground, and in the air the
   // level he last stood on, so a jump does not shrink the wall ahead and a stair step is one
   // tile tall from the step below it, not four from the floor
@@ -66,14 +66,28 @@
     if (dx >= 0 && dx <= 16) enemies.push({kind: c.title, dx: Math.round(dx * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) < 0 ? 'toward' : 'away'});
     else if (back >= 0 && back <= 8) behind.push({kind: c.title, dx: Math.round(back * 10) / 10, dy: Math.round(dy * 10) / 10, dir: (c.xvel || 0) > 0 ? 'toward' : 'away'});
   });
-  var floors = (window.solids || []).filter(function(s){ return s.alive && (s.title === 'Floor' || s.title === 'Stone') && s.top >= p.bottom - 4; });
-  var x = p.right, gapStart = null;
-  for (var i = 0; i <= 12 * T; i += T / 4) {
-    var covered = floors.some(function(f){ return f.left <= x + i && x + i <= f.right; });
-    if (!covered && gapStart === null) gapStart = i;
-    if (covered && gapStart !== null) { if (i - gapStart >= T / 2) gaps.push({dx: tiles(gapStart), width: tiles(i - gapStart)}); gapStart = null; }
+  // the ground ahead as a profile from where Mario stands: each quarter tile, the highest surface
+  // of floor, stone or pipe within five tiles above his level and eight below it (the block rows
+  // float higher: run under, never walked on). No surface at all is a pit; a surface a tile or
+  // more below his level is a drop, until the ground is back level, or a wall, or a pit. Read
+  // from his level and not from his feet: below the floor's top (falling into a gap, standing in
+  // the slot between two stairs) the floor is still there, and read from his feet it vanished,
+  // the "gap 12 tiles wide" three lives were lost to
+  var terrain = (window.solids || []).filter(function(s){ return s.alive && (s.title === 'Floor' || s.title === 'Stone' || s.title === 'Pipe'); });
+  function surface(x0, x1){ var best = null; terrain.forEach(function(f){ if (f.left < x1 && x0 < f.right && f.top >= ground - 5 * T && f.top <= ground + 8 * T && (best === null || f.top < best)) best = f.top; }); return best === null ? null : Math.round((ground - best) / T * 10) / 10; }
+  var x = p.right, prof = [];
+  for (var i = 0; i <= 14 * T; i += T / 4) prof.push(surface(x + i, x + i + 1));
+  var gapStart = null, dropStart = null;
+  for (var k = 0; k < prof.length; k++) {
+    var h = prof[k];
+    if (h === null) { if (gapStart === null) gapStart = k; }
+    else if (gapStart !== null) { if (k - gapStart >= 2) gaps.push({dx: tiles(gapStart * T / 4), width: tiles((k - gapStart) * T / 4)}); gapStart = null; }
+    if (h !== null && h <= -1) { if (dropStart === null) dropStart = k; }
+    else if (dropStart !== null) { drops.push({dx: tiles(dropStart * T / 4), depth: -Math.min.apply(null, prof.slice(dropStart, k)), width: tiles((k - dropStart) * T / 4), then: h === null ? 'pit' : (h >= 1 ? 'wall' : 'level')}); dropStart = null; }
   }
-  if (gapStart !== null && 12 * T - gapStart >= T / 2) gaps.push({dx: tiles(gapStart), width: tiles(12 * T - gapStart)});
+  if (gapStart !== null && prof.length - gapStart >= 2) gaps.push({dx: tiles(gapStart * T / 4), width: tiles((prof.length - gapStart) * T / 4), open: true});
+  if (dropStart !== null) drops.push({dx: tiles(dropStart * T / 4), depth: -Math.min.apply(null, prof.slice(dropStart)), width: tiles((prof.length - dropStart) * T / 4), then: 'unknown'});
+  var overPit = !p.resting && surface(p.left, p.right) === null;
   (window.solids || []).forEach(function(s){
     if (!s.alive || ['Pipe','Block','Brick','Stone'].indexOf(s.title) < 0) return;
     // anything whose far edge is still ahead of Mario counts, including the pipe he is pressed
@@ -107,7 +121,7 @@
   return {ready: true, x: tiles(p.left), y: tiles(ground - p.bottom), level_x: tiles(p.left + (window.__s1scroll || 0)),
           dying: !!p.dying,
           screen_tiles: tiles(sr - sl), xvel: Math.round((p.xvel || 0) * 10) / 10, yvel: Math.round((p.yvel || 0) * 10) / 10, on_ground: !!p.resting, dead: !!p.dead,
-          power: p.power || 1, enemies: enemies.slice(0, 3), behind: behind.slice(0, 2), gaps: gaps.slice(0, 2), walls: walls.slice(0, 2), blocks: blocks.slice(0, 2), overhead: overhead.slice(0, 4),
+          power: p.power || 1, enemies: enemies.slice(0, 3), behind: behind.slice(0, 2), gaps: gaps.slice(0, 2), drops: drops.slice(0, 2), over_pit: overPit, walls: walls.slice(0, 2), blocks: blocks.slice(0, 2), overhead: overhead.slice(0, 4),
           lives: amt('lives'), time: amt('time'), score: amt('score'), coins: amt('coins'), world: amt('world'), paused: !!window.paused,
           ending: !!(window.map && map.ending)};
 })()"""
@@ -160,6 +174,8 @@ def __init__(self):
         self._lives = None
         self._restarting_until = 0.0
         self._held: set[int] = set()
+        self._armed = None         # the landing re-press a jump chosen in the air is waiting for
+        self._world = None         # the level the run started in; the next one means it is cleared
 
     def _run(self, coro, timeout: float = 120.0):
         return asyncio.run_coroutine_threadsafe(coro, self._loop).result(timeout)
@@ -227,20 +243,52 @@ async def _up(self, *codes: int) -> None:
                 self._held.discard(c)
 
     async def _tick(self, name: str) -> None:
-        """The key state each action means, held for one tick. The environment executes; it
-        does not time anything for the model: where to leave the ground is the model's call,
-        from the facts the state and its instructions carry."""
+        """The key state each action means. The environment executes; it does not time anything
+        for the model: where to leave the ground is the model's call, from the facts the state
+        and its instructions carry. The keys are set and the call returns; the game runs on
+        while the next decision is made."""
         R, S, U, L = KEY["right"], KEY["sprint"], KEY["jump"], KEY["left"]
         keys = {"run_right": (R, S), "jump_right": (R, S, U), "jump": (U,), "walk_left": (L,), "wait": ()}[name]
-        if U in keys and U in self._held and await self._eval("!!player.resting"):
-            # "jump" means press jump: a key still held from the last jump would do nothing on
-            # the ground (the game wants a release first), so it is let go and pressed again,
-            # the way a thumb does. Recorded: four lives to a jump that never happened
-            await self._eval(f"keyup({U}); 'ok'")
-            self._held.discard(U)
-            await asyncio.sleep(0.04)
+        if self._armed is not None:
+            self._armed.cancel()
+            self._armed = None
+        if U in keys:
+            if await self._eval("!!player.resting"):
+                if U in self._held:
+                    # "jump" means press jump: a key still held from the last jump would do nothing on
+                    # the ground (the game wants a release first), so it is let go and pressed again,
+                    # the way a thumb does. Recorded: four lives to a jump that never happened
+                    await self._eval(f"keyup({U}); 'ok'")
+                    self._held.discard(U)
+                    await asyncio.sleep(0.04)
+            else:
+                # in the air the jump key stays held and is pressed again the moment Mario lands: a
+                # held jump button is a jump on landing, the way a thumb plays it, and any later
+                # action cancels it. Recorded nine times in a row: the jump over the fourth pipe
+                # comes down a tile before the first gap, and no decision could arrive in time
+                self._armed = self._loop.create_task(self._jump_on_landing())
         await self._keys(*keys)
-        await asyncio.sleep(TICK)
+
+    async def _jump_on_landing(self) -> None:
+        U = KEY["jump"]
+        for _ in range(150):
+            await asyncio.sleep(0.016)
+            if await self._eval("!!player.dead || !!player.dying"):
+                return
+            if await self._eval("!!player.resting"):
+                break
+        else:
+            return
+        # one evaluation, so a cancellation cannot leave the key half way: the game takes the
+        # release and the press in the same tick
+        await self._eval(f"keyup({U}); keydown({U}); 'ok'")
+        self._held.add(U)
+
+    async def _down(self, *codes: int) -> None:
+        for c in codes:
+            if c not in self._held:
+                await self._eval(f"keydown({c}); 'ok'")
+                self._held.add(c)
 
     async def _unstick(self) -> None:
         """Held into a pipe's side in the air, Mario "falls" in place at terminal speed for as long
@@ -279,6 +327,7 @@ async def go():
                 pass
             return {"ok": True}
         self.steps = 0
+        self._world = None
         return self._run(go())
 
     def observe(self) -> dict:
@@ -324,7 +373,7 @@ def lag(self) -> float:
         if len(gaps) < 3:
             return 0.3
         gaps.sort()
-        return min(0.9, max(0.12, gaps[len(gaps) // 2] - TICK))
+        return min(0.9, max(0.12, gaps[len(gaps) // 2]))
 
     def act(self, name: str) -> dict:
         self._acted_at.append(time.time())
@@ -341,14 +390,17 @@ async def go():
         d["text"] = f"{name}: holding {held}. " + d["text"]
         return d
 
-    def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks: list, overhead: list) -> str:
+    def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks: list, overhead: list, drops: list) -> str:
         """What the measured facts call for, said for the moment the decision will land: a
-        decision arrives about a quarter second after this state, and at a run Mario covers
-        2.5 tiles in that time, so every distance here is projected by that much. Measured on
-        the live game: a running jump started 3 to 4 tiles before the first Goomba survives
-        every time (5 to 9 tiles hits the block row and drops onto it); a 4-tile pipe is cleared
-        by a long jump taken 2 to 3 tiles before it at speed; a gap by a running jump from its
-        edge. The environment executes nothing here; the model reads it and chooses."""
+        decision lands a fraction of a second after this state, and at a run Mario covers two
+        to three tiles in that time, so every distance here is projected by that much. The
+        nearest thing ahead governs; a farther one waits its turn (recorded: a gap five tiles
+        on outranked the one-tile step Mario was pressed against, for 284 decisions, until the
+        clock ran out). Measured on the live game: a running jump started 1.5 to 4 tiles before
+        the first Goomba survives (5 to 9 tiles hits the block row above it and drops onto it);
+        a 4-tile pipe is cleared by a long jump taken 2 to 3 tiles before it at speed; a gap or
+        a drop by a jump from its edge; and a jump held in the air goes again as Mario lands, so
+        hops chain. The environment executes nothing here; the model reads it and chooses."""
         held = KEY["jump"] in self._held
         on_ground = st.get("on_ground")
         xv = abs(st.get("xvel") or 0)
@@ -356,26 +408,29 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
         lag = round(xv * 60 * self.lag() / (8 * 4), 1)    # tiles covered before the decision lands, at the measured pace
         rising = (st.get("yvel") or 0) < 0
         if not on_ground:
+            if st.get("over_pit"):
+                return "Mario is over the gap and nothing changes the fall now; when he has died, wait."
             if held and rising:
                 return "keep jump_right held: Mario is still rising, and the jump grows as long as it is held."
-            # measured: right kept through the descent lands 9.4 tiles on and slides 2 more; left
-            # held brakes the flight to 6.8 tiles and lands him stopped. Recorded five times: the
-            # jump over the fourth pipe lands a tile before the first gap and the run carries him in
-            gap_close = gaps and gaps[0]["dx"] <= 4.5
-            foe_close = any(abs(e["dy"]) < 1 and e["dx"] <= 4 for e in en)
-            if fast and (gap_close or foe_close):
-                what = "the gap" if gap_close else "the enemy"
-                return f"walk_left now: in the air it brakes, and Mario lands stopped short of {what}; then jump_right from there at a run."
+            # recorded nine times in a row: the jump over the fourth pipe comes down a tile before
+            # the first gap, and neither a brake in the air (he dropped in from 0.8 tiles) nor the
+            # run (it carried him in before the next decision) saved him. A held jump goes again
+            # the moment he lands, so the hop over what is ahead is chosen now, in the air
+            soon = ((gaps and gaps[0]["dx"] <= 12) or (drops and drops[0]["dx"] <= 12) or (walls and walls[0]["dx"] <= 12)
+                    or any(e["dx"] <= 12 and e["dy"] > -1 for e in en))
+            if soon:
+                return "jump_right, and keep it held: the held jump goes again the moment Mario lands, over what is ahead."
             return "falling: run_right keeps the run."
         near = next((e for e in en if abs(e["dy"]) < 1), None)
-        near_next = (near["dx"] - lag - (0.5 if near.get("dir") == "toward" else 0)) if near else None
+        toward = near is not None and near.get("dir") == "toward"
+        takeoff = (near["dx"] - lag - (0.5 if toward else 0)) if near else None   # where a jump chosen now leaves the ground
         back = next((b for b in st.get("behind") or [] if b.get("dir") == "toward" and abs(b["dy"]) < 1 and b["dx"] <= 2.5), None)
+        above = next((e for e in en if e["dy"] > 1 and e["dx"] <= 5 and e.get("dir") == "toward"), None)
         # an enemy about to touch him outranks everything: it is the lethal thing. Measured: from
         # standing, jump_right as it arrives (1 to 2.5 tiles) survives every time
-        above = next((e for e in en if e["dy"] > 1 and e["dx"] <= 5 and e.get("dir") == "toward"), None)
         if near is not None and near["dx"] <= 4 and not fast:
-            if near.get("dir") == "toward":
-                return "jump_right now: the enemy is about to reach Mario." if near_next <= 2.2 else "wait, standing still; jump_right when it is 2 tiles away."
+            if toward:
+                return "jump_right now: the enemy is about to reach Mario." if takeoff <= 2.2 else "wait, standing still; jump_right when it is 2 tiles away."
             return "walk_left one decision to make room, then run_right and jump_right when it is about 6 tiles ahead."
         if back is not None and not fast:
             return "jump, standing (the jump tool, not jump_right): the enemy at Mario's back passes under him."
@@ -383,35 +438,66 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
             # recorded five times: the Goomba on the ledge walks off its edge and drops onto a Mario
             # running under it
             return "wait, standing still: the enemy above is about to drop off its ledge; jump_right when it is 2 tiles away at Mario's height."
-        if walls and walls[0]["height"] >= TALL and walls[0]["dx"] <= 8:
-            # measured: the pipe is cleared at near full speed (4.9 and up) with the jump held
-            # long; at a jog the apex is level with its top and the side stops him (recorded)
-            w = walls[0]; w_next = w["dx"] - lag
-            full = xv >= 4.5
-            follower = next((b for b in st.get("behind") or [] if b.get("dir") == "toward" and abs(b["dy"]) < 1 and b["dx"] <= 6), None)
-            if not full and w["dx"] <= 4.5:
-                if follower is not None:
-                    return "jump, standing (the jump tool): the enemy behind passes under; then walk_left two decisions and run at the pipe."
-                return "too slow for the pipe from here: walk_left for two decisions, then run_right to full speed and jump_right at 2 to 3 tiles."
-            if not full:
-                return "run_right to full speed; jump_right when the pipe is about 5 tiles ahead and Mario is running flat out."
-            if 1.8 <= w_next <= 3.4:
-                return "jump_right now, and keep it held for three decisions: the pipe's take-off point is here."
-            if w_next < 1.8:
-                return "jump_right now and hold it three decisions."
-            return "run_right toward the pipe; jump_right when it is about 5 tiles ahead at this speed."
+        things = []
+        if walls and walls[0]["dx"] <= 8:
+            things.append((walls[0]["dx"], "wall"))
+        if drops and drops[0]["dx"] <= 12:
+            things.append((drops[0]["dx"], "drop"))
+        if gaps and gaps[0]["dx"] <= 14:
+            things.append((gaps[0]["dx"], "gap"))
         if near is not None and near["dx"] <= 9:
+            things.append((near["dx"], "enemy"))
+        things.sort()
+        kind = things[0][1] if things else None
+        if kind == "wall":
+            w = walls[0]; w_next = w["dx"] - lag
+            if w["height"] >= TALL:
+                # measured: the pipe is cleared at near full speed (4.9 and up) with the jump held
+                # long; at a jog the apex is level with its top and the side stops him (recorded)
+                w = walls[0]; w_next = w["dx"] - lag
+                full = xv >= 4.5
+                follower = next((b for b in st.get("behind") or [] if b.get("dir") == "toward" and abs(b["dy"]) < 1 and b["dx"] <= 6), None)
+                if not full and w["dx"] <= 4.5:
+                    if follower is not None:
+                        return "jump, standing (the jump tool): the enemy behind passes under; then walk_left two decisions and run at the pipe."
+                    return "too slow for the pipe from here: walk_left for two decisions, then run_right to full speed and jump_right at 2 to 3 tiles."
+                if not full:
+                    return "run_right to full speed; jump_right when the pipe is about 5 tiles ahead and Mario is running flat out."
+                if 1.8 <= w_next <= 3.4:
+                    return "jump_right now, and keep it held for three decisions: the pipe's take-off point is here."
+                if w_next < 1.8:
+                    return "jump_right now and hold it three decisions."
+                return "run_right toward the pipe; jump_right when it is about 5 tiles ahead at this speed."
+            if w_next <= 1.5:
+                return "jump_right now over the " + w["kind"] + " ahead" + (": a hop clears a step." if w["height"] <= 1 else ".")
+            return "run_right; jump_right when the " + w["kind"] + " is about a tile and a half ahead at this pace."
+        if kind == "drop":
+            d = drops[0]
+            if d["dx"] - lag <= 1.5:
+                return "jump_right now across the drop: the hop lands past it, and walking off the edge falls in."
+            return "run_right; jump_right at the drop's edge, never off it."
+        if kind == "enemy":
             if fast:
-                # measured: under the block row the take-off must be 3 to 4 tiles before it; in the
-                # open a running jump from farther lands past it just the same. The jump goes when
-                # the next state would already be past the window at this pace
-                if near_next <= (3.8 if overhead else 5.5) or near_next - lag <= 1.5:
-                    return "jump_right now over the enemy: at this speed the take-off comes a few tiles before it."
-                return "run_right; jump_right the moment the enemy comes within reach."
-            if near.get("dir") == "toward":
-                return "jump now, standing: it is about to reach Mario." if near_next <= 1.5 else "wait, standing still; jump when it is 2 tiles away."
+                # measured: under the block row the take-off must be 1.5 to 4 tiles before it (5 to 9
+                # hits the blocks and drops onto it); in the open a running jump from farther lands
+                # past it just the same. The jump goes when the take-off falls in the window, or now
+                # when the next state would already be past it; under the blocks a miss is a death,
+                # so there the stop and the standing jump (8 of 8) take over instead
+                under_blocks = any(o["dx"] <= near["dx"] + 1 for o in overhead)
+                lo, hi = (1.5, 4.0) if under_blocks else (1.5, 6.5)
+                if lo <= takeoff <= hi:
+                    return "jump_right now over the enemy: this is the take-off."
+                if takeoff > hi:
+                    if takeoff - (lag + 0.6) >= lo:
+                        return "run_right; jump_right the moment the enemy comes within reach."
+                    if under_blocks:
+                        return "walk_left now to stop short of the enemy (a jump from here hits the blocks above it); then jump_right when it is 1 to 2.5 tiles away."
+                    return "jump_right now over the enemy: the next decision would come too late."
+                return "jump_right now over the enemy: the last chance."
+            if toward:
+                return "jump now, standing: it is about to reach Mario." if takeoff <= 1.5 else "wait, standing still; jump when it is 2 tiles away."
             return "run_right after it; jump_right when it is about 7 tiles ahead at a run."
-        if gaps and gaps[0]["dx"] <= 14:
+        if kind == "gap":
             g = gaps[0]["dx"]; g_next = g - lag
             # recorded six times: the jump across lands nine tiles on, among the enemies waiting
             # there (a pair beyond the gap, a Goomba dropping off its ledge). Ones walking toward
@@ -434,8 +520,6 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
             if g >= 3.5:
                 return "run_right to gain speed for the gap; jump_right the moment its edge comes within reach."
             return "too slow for the gap: walk_left two decisions, then run_right and jump_right at its edge."
-        if walls and walls[0]["dx"] - lag <= 1.5:
-            return "jump_right now over the wall ahead."
         if blocks and blocks[0]["dx"] - lag <= 1.8:
             return "jump_right now, under the question block, for the coin."
         return "nothing within reach: run_right."
@@ -443,6 +527,14 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
     def _describe(self, st: dict) -> dict:
         if not st.get("ready"):
             return {"ok": True, "text": "The game is loading.", "fields": {"ready": False}, "candidates": {}, "terminal": False, "realtime": True}
+        if self._world is None and st.get("world"):
+            self._world = st["world"]
+        if st.get("ending") or (self._world and st.get("world") and st.get("world") != self._world):
+            # the flag: the game plays its own walk to the castle and rolls into the next level
+            # (recorded: the follower was well into the underground before anything said so)
+            return {"ok": True, "text": f"Level {self._world} is cleared: Mario reached the flag. Lives {st.get('lives')}, coins {st.get('coins')}, score {st.get('score')}. Finish.",
+                    "fields": {"cleared": True, "world": self._world, "lives": st.get("lives"), "coins": st.get("coins"), "score": st.get("score")},
+                    "candidates": {}, "terminal": True, "realtime": True}
         restarting = self._restarting(st)
         if restarting:
             lives = st.get("lives")
@@ -460,7 +552,7 @@ def _describe(self, st: dict) -> dict:
         if en:
             e = en[0]
             where = "at Mario's height" if abs(e["dy"]) < 1 else ("above" if e["dy"] > 0 else "below")
-            arrives = f", at Mario in about {max(1, round(e['dx'] / (1.5 * (self.lag() + TICK))))} decisions if he stands still" if e.get("dir") == "toward" and abs(e["dy"]) < 1 else ""
+            arrives = f", at Mario in about {max(1, round(e['dx'] / (1.5 * self.lag())))} decisions if he stands still" if e.get("dir") == "toward" and abs(e["dy"]) < 1 else ""
             parts.append(f"Nearest enemy: {e['kind']} {e['dx']} tiles ahead, {where}, walking {'toward Mario' if e.get('dir') == 'toward' else 'away'}{arrives}."
                          + (f" {len(en) - 1} more behind it." if len(en) > 1 else ""))
         else:
@@ -470,13 +562,25 @@ def _describe(self, st: dict) -> dict:
             b = back[0]
             parts.append(f"Behind Mario: {b['kind']} {b['dx']} tiles back, walking {'toward him' if b.get('dir') == 'toward' else 'away'}.")
         gaps = st.get("gaps") or []
-        parts.append(f"Gap in the ground: edge {gaps[0]['dx']} tiles ahead, {gaps[0]['width']} tiles wide; a running jump from the edge crosses it, a standing one falls in." if gaps
-                     else "No gap in the ground within 12 tiles.")
+        drops = st.get("drops") or []
+        if st.get("over_pit"):
+            parts.append("Mario is over a gap, falling.")
+        elif gaps:
+            g = gaps[0]
+            width = f"at least {g['width']} tiles wide, its far side out of sight" if g.get("open") else f"{g['width']} tiles wide"
+            parts.append(f"Gap in the ground: edge {g['dx']} tiles ahead, {width}; a running jump from the edge crosses it, a standing one falls in.")
+        else:
+            parts.append("No gap in the ground within 14 tiles.")
+        if drops:
+            d = drops[0]
+            then = {"level": "comes back level", "wall": "meets a wall", "pit": "opens into a gap"}.get(d["then"], "goes on out of sight")
+            parts.append(f"The ground drops {d['depth']} tiles, {d['dx']} tiles ahead, for {d['width']} tiles, then {then}; "
+                         "jump_right from the edge lands past it, and walking off the edge falls in.")
         walls = st.get("walls") or []
         if walls:
             w = walls[0]
             need = ("a jump held for three decisions from a run, leaving the ground 2 to 3 tiles before it; from against it or from standing it is never cleared"
-                    if w["height"] >= TALL else "a jump held for two decisions" if w["height"] >= 3 else "a jump")
+                    if w["height"] >= TALL else "a jump held for two decisions" if w["height"] >= 3 else "a hop (jump_right)" if w["height"] <= 1 else "a jump")
             parts.append(f"Wall ahead: {w['kind']} {w['dx']} tiles ahead, {w['height']} tiles tall; it takes {need}.")
         else:
             parts.append("No pipe or wall within 8 tiles.")
@@ -496,27 +600,30 @@ def _describe(self, st: dict) -> dict:
         # at a run is already too close to jump, so it is named a step earlier than it arrives
         # at the loop's measured pace: at a full run (9 tiles a second) a third of a second is
         # 3 tiles, and a walking enemy adds about half a tile of its own
-        reach = round(max(0.5, abs(st.get("xvel") or 0) * 60 * (self.lag() + TICK) / (8 * 4)), 1)
+        reach = round(max(0.5, abs(st.get("xvel") or 0) * 60 * self.lag() / (8 * 4)), 1)
         closing = round(reach + 0.6, 1)
         within = [f"the {en[0]['kind']} {en[0]['dx']} tiles ahead"] if en and en[0]["dx"] <= closing + 2.5 else []
         within += [f"the gap {gaps[0]['dx']} tiles ahead"] if gaps and gaps[0]["dx"] <= reach + 0.5 else []
+        within += [f"the drop {drops[0]['dx']} tiles ahead"] if drops and drops[0]["dx"] <= reach + 0.5 else []
         within += [f"the {walls[0]['kind']} {walls[0]['dx']} tiles ahead"] if walls and walls[0]["dx"] <= reach + 0.5 else []
         within += [f"the question block {blocks[0]['dx']} tiles ahead"] if blocks and blocks[0]["dx"] <= reach + 0.5 else []
         parts.append(f"Until the next decision Mario covers about {reach} tiles, and a walking enemy closes about {closing}. "
                      + (f"Within one step: {'; '.join(within)}." if within else "Nothing is within one step."))
-        parts.append("Now: " + self._now(st, reach, en, gaps, walls, blocks, overhead))
+        parts.append("Now: " + self._now(st, reach, en, gaps, walls, blocks, overhead, drops))
         if self._stopped >= 2:
             parts.append(f"Mario has been stopped in place for {self._stopped} decisions by something he is pressed "
-                         "against: walk_left, then run_right, then jump_right at 2 to 3 tiles.")
+                         "against: jump_right hops a step; a tall pipe takes walk_left, then run_right, then jump_right at 2 to 3 tiles.")
         held = [KEY_NAMES[c] for c in self._held]
         if KEY["jump"] in self._held and not st.get("on_ground"):
-            parts.append("The jump key is held; it keeps the jump growing while Mario rises.")
+            parts.append("The jump key is held; it keeps the jump growing while Mario rises"
+                         + (", and goes again the moment he lands." if self._armed is not None and not self._armed.done() else "."))
         parts.append(f"Lives {st.get('lives')}, coins {st.get('coins')}, time {st.get('time')}, score {st.get('score')}.")
-        terminal = bool(st.get("ending")) or (bool(st.get("dead")) and (st.get("lives") or 0) <= 0)
+        terminal = bool(st.get("dead")) and (st.get("lives") or 0) <= 0
         fields = {k: st.get(k) for k in ("x", "y", "level_x", "on_ground", "dead", "xvel", "lives", "coins", "time", "score", "world")}
         fields["enemies"] = en
         fields["behind"] = st.get("behind") or []
         fields["gaps"] = gaps
+        fields["drops"] = drops
         fields["walls"] = walls
         fields["blocks"] = blocks
         fields["stopped_steps"] = self._stopped

From 49b860d47baad0e2b02ec4f0ba0529a3d4ea57a7 Mon Sep 17 00:00:00 2001
From: richard-epsilla <richard@epsilla.com>
Date: Sun, 20 Sep 2026 02:47:29 -0700
Subject: [PATCH 26/26] mario: the ledge wait never fires with a gap at Mario's
 feet, and the README says what the environment is now

The follower's one death on the level: the wait for the Goomba above to drop off its
ledge let every key go a tile before the 3-tile gap. The nearest thing decides.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 kits/mario/README.md                  | 66 +++++++++++++--------------
 kits/mario/plugin/plugin.json         |  2 +-
 kits/mario/plugin/server/mario_env.py |  6 ++-
 3 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/kits/mario/README.md b/kits/mario/README.md
index d02799f..b19fbe8 100644
--- a/kits/mario/README.md
+++ b/kits/mario/README.md
@@ -31,40 +31,38 @@ rate of frames it actually displayed.
 
 ### What is measured, not tuned
 
-The state is literal and the numbers in it come from the game: where Mario is, the nearest enemy
-ahead and whether it walks toward him, the nearest enemy behind him, the next gap, wall and
-question block with distances in tiles, and how far one step reaches. The things below were
-measured on the live game and written into the environment rather than left to the model:
-
-- **Jump heights.** Feet above the ground at the apex: a short hold reaches 3.1 tiles, a medium 3.9,
-  a long 4.1, standing or at a run. So the state says which hold clears the wall ahead (short for
-  2 tiles, medium for 3, long for 4), and when the model's hold is shorter than what lies ahead
-  needs, the environment takes the needed one and says so in the result.
-- **When to leave the ground.** A decision lands every half second and a jump is a one-tile affair.
-  A wall 4 tiles tall is cleared by a long jump from 1.5 to 3 tiles back and from nowhere else; a
-  running jump covers about 9 tiles, so a gap is left from its edge at speed; a question block is
-  hit by a jump started 1 to 1.5 tiles before it at a run and missed from 2. So `jump_right` keeps
-  running until the nearest thing ahead is at its distance, steps back first when there is no room
-  for the run-up (and nothing behind), and waits for the landing when asked to jump mid-air.
-- **Enemies.** A running jump over the first Goomba hit the block row above it and dropped Mario
-  onto it, every life. An enemy walking toward Mario is instead let under a standing jump taken
-  when it is about one tile away (six of six tries between 0.8 and 1.2 tiles), and `run_right`
-  stops five tiles short of an enemy walking at him so that jump is taken standing. An enemy
-  below him, when he stands on a pipe, is waited out rather than jumped onto.
-
-The model decides to jump; the timing is the environment's, the way holding the keys is. Heights
-are measured from where Mario stands (his feet on the ground, the level he last stood on in the
-air), so a jump does not shrink the wall ahead and a stair step is one tile tall from the step
-below it.
-
-On the model's own runs after these changes (Jev 1.13 through OpenRouter, 400 steps): all four
-pipes of the first level are cleared, the question blocks pay (10 coins and a score of 17,300 in
-one 119-action run), the run moves at about two seconds an action, and the furthest point reached
-is about half the level. The level is not won yet: the lives go to the Goomba pair pacing around
-the third and fourth pipes, to the landing beyond the 3-tile gap where a Goomba waits, and to a
-pair near the middle of the level. Each of those is a state question, not a model question, and
-each earlier death class was removed the same way: read the trace, measure the game, write the
-fact into the environment.
+The state is literal and the numbers in it come from the game: where Mario is and whether he is
+on the ground, the ground ahead as a profile (the next gap, the next drop and what follows it, the
+next step or wall and its height), the nearest enemy ahead and whether it walks toward him, the
+nearest enemy behind him, the block rows overhead, the next question block, how far one decision
+carries him at the loop's own measured pace, and a closing line beginning "Now:" that says what the
+measured facts call for at this moment. The environment executes key states and times nothing:
+an action sets the keys and returns, the keys stay set until the next action, and the model
+chooses every step. Two things about the keys are the input layer's, the way a thumb plays:
+
+- **A jump means a press.** `jump_right` or `jump` on the ground with the jump key still held from
+  the last jump lets it go and presses it again; the game wants the release.
+- **A jump held in the air goes again on landing.** `jump_right` chosen while Mario is in the air
+  keeps the key down and presses it the moment he lands (any later action cancels it), so hops
+  chain the way they do under a held button. Recorded nine times in a row before this: the jump
+  over the fourth pipe comes down a tile before the first gap, and no decision could arrive in
+  time; the hop is now chosen in the air.
+
+The facts the "Now:" line and the kit's instructions carry were measured on the live game, not
+tuned: a running jump started 1.5 to 4 tiles before the first Goomba survives, 5 to 9 tiles hits
+the block row and drops onto it, so when that window cannot be hit at the loop's pace the stop and
+the standing jump (1 to 2.5 tiles, eight of eight) take over; a 4-tile pipe is cleared only at a
+full run with the jump held long, taken 2 to 3 tiles before it; a gap or a drop is left from its
+edge; a one-tile step is a hop and a stair is a hop per step; the ground is read from Mario's level
+rather than his feet, so the floor is still there when he is below its top (read from his feet it
+vanished, and three lives went to a "gap 12 tiles wide"); and the nearest thing ahead decides (a
+gap five tiles on outranked the one-tile step he was pressed against for 284 decisions, until the
+clock ran out). Each of these came from a recording: a copy of every frame the page shows, cut into
+a contact sheet around each death, read, then measured with a probe before the environment changed.
+
+A player that obeys the state's own "Now:" line with a model-like delay of 0.2 s is the
+environment's test bench, apart from any model: on the level's current environment it clears 1-1
+in 50 game seconds with one death (2026-09-20). The model's own runs are recorded the same way.
 
 ### Launching again after an update
 
diff --git a/kits/mario/plugin/plugin.json b/kits/mario/plugin/plugin.json
index d7c8879..b7af2ed 100644
--- a/kits/mario/plugin/plugin.json
+++ b/kits/mario/plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "mario-env",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Full Screen Mario as an environment for the System One base: the game's state as literal text each step, the keys it listens to as actions, and the browser's frame for the page to show.",
   "homepage": "https://github.com/HarnessRouter/starter-kit",
   "license": "SEE LICENSE IN ../LICENSE.md"
diff --git a/kits/mario/plugin/server/mario_env.py b/kits/mario/plugin/server/mario_env.py
index a1d7ef6..c00bc96 100644
--- a/kits/mario/plugin/server/mario_env.py
+++ b/kits/mario/plugin/server/mario_env.py
@@ -434,9 +434,11 @@ def _now(self, st: dict, reach: float, en: list, gaps: list, walls: list, blocks
             return "walk_left one decision to make room, then run_right and jump_right when it is about 6 tiles ahead."
         if back is not None and not fast:
             return "jump, standing (the jump tool, not jump_right): the enemy at Mario's back passes under him."
-        if above is not None and (near is None or near["dx"] > 6):
+        edge = min([g["dx"] for g in gaps] + [d["dx"] for d in drops] + [99])
+        if above is not None and (near is None or near["dx"] > 6) and edge > lag + 3:
             # recorded five times: the Goomba on the ledge walks off its edge and drops onto a Mario
-            # running under it
+            # running under it. Not with a gap at his feet: letting the keys go a tile before the
+            # 3-tile gap dropped him in (the follower's one death on the level)
             return "wait, standing still: the enemy above is about to drop off its ledge; jump_right when it is 2 tiles away at Mario's height."
         things = []
         if walls and walls[0]["dx"] <= 8: