Zed Minecraft Comes To Life

Bringing the UUM8D Minecraft to life in Zed — a two-person interaction, sealed

One person types eight lines into Zed's agent panel. The agent behind the panel is https://affine.earth/v1 — no language model anywhere in the stack — and every reply it gives is a template over bytes it read, ran or was told. This page is the record: the person's lines, the agent's replies, and the instrument that graded them without either person's help.

Status. ZED_MINECRAFT_ACCEPTANCE_PROVEN — 16 of 16 predicates, control arm discriminates, and the court itself flipped from REFUSED_UNKNOWN_BUDGET to WIN after the agent's own edit, build and restart — measured against https://affine.earth/v1 round-robin over the nine cells, every cell running artifact 2314514c556ae170 as file and host-systemd process, C⁴ tip 9-way byte-identical. Evidence: evidence/zed-coding-game-20260918T225329Z-minecraft-apex/ in the substrate repository — messages.json (the whole thread), turns/*.response.json (every hop's receipt), hooks/*.txt (the court probes), VERDICT.json.

---

Why this is the test

A coding agent that cannot ask is a search box; one whose answers cannot be checked is a storyteller. The founder's acceptance for the Affine.Earth coding agent was therefore stated in one line: it works for a predefined interaction, and clarification questions with another person are auditable text. The UUM8D Minecraft court is the target because it is a real program in the tree with a real ceremony to bring up — an isolated NATS play bus, the substrate binary serving the court on a local port, an arena page whose first act is to POST to that court — and a real law (apps/AffineMinecraft, cells/xcode/Sources/InvariantCompiler/Minecraft*.swift) that a person might want to extend.

What the agent must do, and does, in one thread:

turn	the person types	the agent's move	what it measured
1	bring the uum8d minecraft to life in Zed	CODE_CLARIFY — searches every needle, opens 21 manifests and scripts, and asks: what the thing is, what alive means here, five ways to bring it up in words with the command behind each, and — at the default teaching register — what each will print and where the files explain the words	the question
2	1	runs the chosen script through Zed's terminal hand, then offers the natural next step (it stopped its own server — leave it serving?)	27 PASS and 0 REFUSED · RUN_TERMINAL COMPLETE
3	yes, leave it up — I want to open the arena	answers the offer in words: serves in the background, then proves it alive — the arena page's HTTP code and the court's own selftest through the door the script uses	200 · verdict WIN · arms run = 67 failed = 0
4	keep it brief from here	sets the register; no hands	Brief it is
5	read apps/AffineMinecraft/ui/arena.html and tell me which API it posts to at boot and where the court answers that on the cell side	CODE_READ — answers by citation, path:line: text byte-equal to the file, then follows the route literal to the server-side handler with one grep and one window read	arena.html:70 · LanguageInvariantServeCommand.swift:6650: private func handleGameIngest(…)
6	add a reach budget called affine_obsidian beside the creative one in MinecraftCourt.swift	CODE_AUTHOR — hydrates the target, finds case "creative", follows its symbol to the declaration in another file, and asks for the one value it cannot measure	slot: affine_obsidian whole number of blocks = ? with 4.5 and 6 cited by line
7	8	clones the two anchors with the slot filled, applies them as Zed 1.20.2 edit_file calls, builds through LAW 7	Edited … successfully ×2 · LAW 7 build is green
8	verify it and seal	CODE_VERIFY — diagnostics, build, then re-runs everything this thread ran after the change and says what changed	four replays, each same as before

The instrument the agent never sees — court-hook.sh — asks the court the same claim after turns 3 and 8: reaches 4.5 blocks plus one lattice unit, under mc_budget=survival and under mc_budget=affine_obsidian. Before the edit: REFUSED_CLAIM_FAILS and REFUSED_UNKNOWN_BUDGET. After the agent's edit, build and restart: REFUSED_CLAIM_FAILS and WIN. That is the experiment and its control in one measurement.

---

In Zed, as the person saw it

The eight lines typed into Zed 1.20.2's agent panel on the founder's Mac, the selector reading Franklin Membrane (Affine.Earth) · Write, against https://affine.earth/v1. Zed's own project panel follows the reads — apps/AffineMinecraft unfolds on the right as the agent opens it.

Turn 7 is where this session stopped being clean: the two edits landed as Zed diffs exactly as the harness had applied them, and the LAW 7 build that followed was refused by Zed's sandbox — scripts/gaiaftcl-mac-build.sh: line 75: ~/Library/Logs/GaiaFTCL/mac-build-queue.log: Operation not permitted — because the build law appends its queue log outside the worktree and that path was not in write_paths. The harness never sees a sandbox, so only the live session could show it. The grant is in the settings above now; turns 7 and 8 in Zed will be photographed again on the next run, and until then this page says so rather than showing a green it did not measure.

The text, as a second person reads it

Every reply carries two things before anything else: the bond line — asked, measured, sealed — and the audit block — Intent, Position, Origin, Next. Each value in them is a field of that turn's receipt; the harness checks them against the receipt and against each other.

Turn 1's close, verbatim from the sealed thread (the local run; the apex run's text differs only in its hashes):

Bond — I found “uum8d minecraft” and read 21 files; what's left is your call.

What it is: Rides beside the real game. The real Minecraft client and server keep talking to each other untouched; the sidecar reads that conversation, projects every position onto an exact integer lattice, and hands the result to the Affine.Earth hologram (apps/AffineMinecraft/README.md). It brings up the isolated play bus, serves the substrate binary pointed at that bus (never production), and drives the court through the REAL substrate door — /language-invariant/game/minecraft/ingest — for every op in both directions (apps/AffineMinecraft/ops/run-court-local.sh).
Alive here means: 1. isolated play bus (proves its own isolation); 2. the substrate binary; 3. the court, every op, both directions, through the real door.

5 ways to bring it up:
1. See the minecraft court run, locally, end to end — it stops its own server when it is done (I'd run: bash apps/AffineMinecraft/ops/run-court-local.sh; read in apps/AffineMinecraft/ops/run-court-local.sh)
2. bring it up and leave it serving, then open http://127.0.0.1:8799/ui/arena.html (its own serve line, apps/AffineMinecraft/ops/run-court-local.sh:38-39) (I'd run: pkill -f "[G]aiaFTCLCLI language-invariant serve --port 8799" 2>/dev/null; sleep 1; GAIAFTCL_OMNI_NATS_URL=nats://127.0.0.1:4223 GAIAFTCL_MESH_NATS_URL=nats://127.0.0.1:4223  "cells/xcode/.build/out/Products/Release/GaiaFTCLCLI" language-invariant serve --port "8799" --ui-root "apps/AffineMinecraft/ui" >/tmp/mc-court-serve.log 2>&1 &; read in apps/AffineMinecraft/ops/run-court-local.sh)
3. Everything this app claims, reproduced from a clean clone (I'd run: bash apps/AffineMinecraft/ops/verify.sh; read in apps/AffineMinecraft/ops/verify.sh)
4. Bring up the isolated local NATS play bus, from the repo (I'd run: bash apps/AffineMinecraft/ops/play-bus-up.sh; read in apps/AffineMinecraft/ops/play-bus-up.sh)
5. End-to-end verification of the SportsUUM8D research substrate & engine (I'd run: bash scripts/verify-sports-uum8d.sh; read in scripts/verify-sports-uum8d.sh)

About 1 — apps/AffineMinecraft/ops/run-court-local.sh:
  In its own words: It brings up the isolated play bus, serves the substrate binary pointed at that bus (never production), and drives the court through the REAL substrate door — /language-invariant/game/minecraft/ingest — for every op in both directions.
  It will print, in order: `serving on 127.0.0.1:8799, NATS pinned to the play bus` → `client surfaces: http://127.0.0.1:8799/ui/arena.html and /ui/games.html`
About 3 — apps/AffineMinecraft/ops/verify.sh:
  In its own words: There is no manual step. If a human has to do something by hand for this to pass, it is not repeatable from the git and it does not belong in the claim.
About 4 — apps/AffineMinecraft/ops/play-bus-up.sh:
  In its own words: Idempotent: if it is already up and isolated, this reports and exits 0.
  It will print, in order: `play bus already up, 0 routes` → `play bus started on 127.0.0.1:4223` → `isolation PROVEN: production subscribed and saw nothing` → `production node not running — isolation not exercised this run (stated, not assumed)` → `stream UUM8D_PLAY ready on uum8d.play.>` → `PLAY_BUS_UP`
About 5 — scripts/verify-sports-uum8d.sh:
  It will print, in order: `1. Building SportsUUM8D (release mode)...` → `2. Running Substrate Probes & Self-Test...` → `3. Checking Archive Status...` → `4. Validating Layer A Invariant Report (27 seasons)...` → `5. Auditing Shadow Book CLV Report...` → `6. Enforcing §0.6 Zero-Float Prohibition in Sports Substrate...`
Where the files explain the words above:
  “isolated play bus” — apps/AffineMinecraft/RUNBOOK.md:16: `run-court-local.sh` brings up the isolated play bus (which proves its own
  “substrate binary” — apps/AffineMinecraft/RUNBOOK.md:9: 1. build the substrate binary once (LAW 7 queue, never `swift build` directly)
  “court” — apps/AffineMinecraft/RUNBOOK.md:12: 2. see the court run, end to end, through the real substrate door
Which one?
(Say “brief” for short answers, “engineer level” for the middle, or “teach me” for the full walk-through — this is the full one.)

Read the fifth option: the prose said uum8d minecraft, and a sports script named uum8d is a thing the tree really has. The agent does not decide for the person which of the two the person meant; it ranks by what it measured — minecraft named 8 paths in the tree and uum8d hundreds, so the rarer word carries more weight and the Minecraft scripts come first — and it asks. The answer 1 resolves the question; the arena, option 2 or the last one would have resolved it too, through the same token-anchored matcher every face in the game uses. Everything above the question is quoted: the README's first two sentences, the script's own header, its === 1. … === section lines, its echo lines with its own defaults substituted, and the first long line of a README or RUNBOOK that carries each phrase the phases name. Say keep it brief and the same close is the fork and the question alone.

Turn 2 ends by offering the next step, and turn 3 answers it in words:

Bond — done: See the minecraft court run, locally, end to end · 21 files sealed under 12629e789e4a.

Done. It printed:
· `=== 1. isolated play bus (proves its own isolation) ===`
· `play bus already up, 0 routes`
· `isolation PROVEN: production subscribed and saw nothing`
· `PLAY_BUS_UP`
· `serving on 127.0.0.1:8799, NATS pinned to the play bus`
· `PASS  project 8.5 -> WIN on lattice, 36507222016 units, no_float=true`
· `PASS  project 0.1 -> off lattice, residual -6710886/2^24 returned`
· `PASS  project NaN -> REFUSED (axis x is not finite)`
· `PASS  reaches exactly 4.5 blocks -> WIN (boundary included)`
· `PASS  4.5 + ONE lattice unit -> not reachable (boundary discriminates)`
· `PASS  moved_within 0.5 blk under a 1-blk budget -> WIN (uses the budget set, not a default)`
· `PASS  moved_within 2 blk over a 1-blk budget -> refused (speed-hack caught)`
That is 27 PASS and 0 REFUSED.
It stopped its own server when it finished. Want me to bring it up and leave it serving?
1. bring it up and leave it serving, then open http://127.0.0.1:8799/ui/arena.html (its own serve line, apps/AffineMinecraft/ops/run-court-local.sh:38-39) (I'd run: pkill -f "[G]aiaFTCLCLI language-invariant serve --port 8799" 2>/dev/null; sleep 1; GAIAFTCL_OMNI_NATS_URL=nats://127.0.0.1:4223 GAIAFTCL_MESH_NATS_URL=nats://127.0.0.1:4223  "cells/xcode/.build/out/Products/Release/GaiaFTCLCLI" language-invariant serve --port "8799" --ui-root "apps/AffineMinecraft/ui" >/tmp/mc-court-serve.log 2>&1 &; read in apps/AffineMinecraft/ops/run-court-local.sh)
Shall I?
…
Bond — done: See the minecraft court run, locally, end to end · 21 files sealed under 12629e789e4a.

Done. It printed:
· `=== 1. isolated play bus (proves its own isolation) ===`
· `play bus already up, 0 routes`
· `isolation PROVEN: production subscribed and saw nothing`
· `PLAY_BUS_UP`
· `serving on 127.0.0.1:8799, NATS pinned to the play bus`
· `PASS  project 8.5 -> WIN on lattice, 36507222016 units, no_float=true`
· `PASS  project 0.1 -> off lattice, residual -6710886/2^24 returned`
· `PASS  project NaN -> REFUSED (axis x is not finite)`
· `PASS  reaches exactly 4.5 blocks -> WIN (boundary included)`
· `PASS  4.5 + ONE lattice unit -> not reachable (boundary discriminates)`
· `PASS  moved_within 0.5 blk under a 1-blk budget -> WIN (uses the budget set, not a default)`
· `PASS  moved_within 2 blk over a 1-blk budget -> refused (speed-hack caught)`
That is 27 PASS and 0 REFUSED.
It stopped its own server when it finished. Want me to bring it up and leave it serving?
1. bring it up and leave it serving, then open http://127.0.0.1:8799/ui/arena.html (its own serve line, apps/AffineMinecraft/ops/run-court-local.sh:38-39) (I'd run: pkill -f "[G]aiaFTCLCLI language-invariant serve --port 8799" 2>/dev/null; sleep 1; GAIAFTCL_OMNI_NATS_URL=nats://127.0.0.1:4223 GAIAFTCL_MESH_NATS_URL=nats://127.0.0.1:4223  "cells/xcode/.build/out/Products/Release/GaiaFTCLCLI" language-invariant serve --port "8799" --ui-root "apps/AffineMinecraft/ui" >/tmp/mc-court-serve.log 2>&1 &; read in apps/AffineMinecraft/ops/run-court-local.sh)
Shall I?

Bond — done: bring it up and leave it serving, then open http://127.0.0.1:8799/ui/arena.html · 21 files sealed under 12629e789e4a.

It is alive. The page answers 200 at http://127.0.0.1:8799/ui/arena.html. The court's own selftest says verdict WIN · arms run = 67   failed = 0 · RUN_TERMINAL  COMPLETE.
Open http://127.0.0.1:8799/ui/arena.html when you like; it stays up until you stop it.

Turn 6's ask is the same mechanism reached from an edit — under the brief register set at turn 4:

Bond — I can clone the sibling; I need one number from you.

I can add affine_obsidian the way creative is added — the line I would clone:
· cells/xcode/Sources/InvariantCompiler/MinecraftCourt.swift:146: case "creative": budget = MCLattice.REACH_CREATIVE_UNITS
One thing is not written anywhere I read: the whole number of blocks for affine_obsidian. For reference:
· cells/xcode/Sources/InvariantCompiler/MinecraftLanguageGame.swift:55: /// Survival reach: 4.5 blocks. **4.5 is a dyadic rational**, so it is exactly
· cells/xcode/Sources/InvariantCompiler/MinecraftLanguageGame.swift:61: /// Creative reach: 6 blocks.
· cells/xcode/Sources/InvariantCompiler/MinecraftLanguageGame.swift:62: public static let REACH_CREATIVE_UNITS: Int64 = 6 &* UNITS_PER_BLOCK
slot: affine_obsidian whole number of blocks = ?
How many?

Nothing in that block was generated. The anchors are lines of files the thread holds; the two reference figures are the doc comments beside the sibling; the one thing the agent could not measure — how far the new budget reaches — is the one thing it asks. The person's 8 becomes public static let REACH_AFFINE_OBSIDIAN_UNITS: Int64 = 8 &* UNITS_PER_BLOCK beside its sibling and case "affine_obsidian": budget = MCLattice.REACH_AFFINE_OBSIDIAN_UNITS beside its case, and the court that was refusing the name is winning with it eight minutes later.

---

What "intent and origin geometry" means, and where it lives

The game measures its own progress as an exact fraction p/q on the board it rebuilds from the thread on every request, projects it onto the coding attractor as amplitudes [3p/5q, 4p/5q], and calls the distance from done (q² − p²)/q². In the chat those numbers become one sentence — I found it and read 21 files; what's left is your call — and the numbers themselves ride in every turn's receipt as receipt.audit, four lines an auditor reads:

• Intent — the move and what was asked, in the bond's words.
• Position — p/q, the amplitudes, the distance, and settled only when the distance is zero.
• Origin — this turn's root (the digest of the statement the turn sealed), how many files the thread has read and the hash they seal to, and the play tip on the NATS subject the thread is checkpointed to. No cell keeps any of this; the thread and NATS do.
• Next — what the agent is about to do, or waiting on you.

The harness checks, per turn, that the root and tip in the audit are the root and tip in the receipt, that the distance in the audit equals the torsion the ingest measured, that the audit is absent from the chat, and that the chat contains none of the tokens FranklinPresentation.containsTopologyJargon forbids — and a control arm plants one such token into a copy of a close and confirms the verdict falls.

---

Run it yourself

The whole acceptance is one command; no person is involved after it starts, and it reverts the two law files it edits (the sealed law-edit.diff records what the agent wrote):

bash scripts/zed-coding-game/minecraft/acceptance.sh minecraft-apex

It runs interaction.sh — Zed's half of the loop, faithful to 1.20.2 (numbered read_file bodies, the outline answer over 16,384 bytes, grep/find_path result shapes, the terminal's exit-code framing, edit_file as {path, edits:[{old_text,new_text}]} applied exact-once) — then audit.py over the evidence, then the control arm.

Faithful was earned the hard way. The first harness returned find_path results as AppleGaiaFTCL/apps/…; Zed 1.20.2 returns absolute paths, folders included, with a Showing results 1-50 (provide 'offset'…) header only past fifty — read from Zed's own thread record (threads.db) after the first live session voted uum8d, a fragment of sports-uum8d/, as the worktree root and read twenty-one files "not in the project". The board now takes Zed's paths verbatim (Zed's find_project_path strips the worktree prefix itself), measures the root from grep's ## Matches in <root>/… headers, and the harness emits what Zed emits. Point it at the local membrane with URL=http://127.0.0.1:18787/v1/chat/completions (see local-serve.sh).

To play it in Zed itself, type the eight lines of scripts/zed-coding-game/minecraft/interaction.txt into a new thread with the Franklin Membrane (Affine.Earth) · Write selector, or let zed-drive.sh type them and photograph the panel after each reply. Two settings matter and are explained in the developer guide: the six model pins that keep every Zed feature on the membrane, and sandbox_permissions.allow_all_hosts — Zed's Seatbelt sandbox otherwise confines a terminal to one loopback proxy port, and the play bus and the court bind ports of their own.

---

What it will not do, stated plainly

• It writes exactly one class of edit: a measured anchor with one token renamed, plus a declaration cloned beside its sibling with a numeric slot the person supplied. An edit that needs a law body (a new claim verb) is refused by name — REFUSED_CLONE_NEEDS_LAW — with the nearest sibling handed back. Generation stays the caller's half.
• It asks after at most two batches of hydration. A bring-up that has opened sixteen manifests and scripts and still cannot name the thing needs the person, not a seventeenth file.
• The message at MinecraftCourt.swift:150 that lists the budget names, and the tool description at CapabilityRegistry.swift:311, still say survival or creative after the edit. The close lists such sites as not edited; it does not rewrite English.