# The Affine Coding Court

**A court whose verdict is the artifact.** Not a grade about code — the finished, runnable thing, or
a named reason you do not have one.

Every number on this page was measured on the live fleet or produced by a test that runs in CI. Where
something is committed but not yet serving, it says so. A document that cannot tell those apart is
the same failure as a court that cannot tell "equivalent" from "finished".

**Measured against the live fleet 2026-09-02: the apex served a brief its own court refused.** `court-client.brief.txt` declares `Target Architecture: Rust no_std wasm32`; the live schema enum carried only three architectures, so the Court Client's prompt → brief → crucible → module flow was `REFUSED_UNKNOWN_ARCHITECTURE` on all nine cells. HEAD already carried the fourth case — a stale fleet binary, not a missing fix. Full measurement, including what the ladder does on an accepted architecture (rung 6, `hasAssembler=false hasWasmRuntime=false`): [MCP court validation, 2026-09-02](MCP-Court-Validation-2026-09-02.md#2-fixed-at-head-waiting-on-the-roll--the-crucible-cannot-accept-the-brief-the-apex-serves).

---

## 1. Why this exists: a 75-turn game that passed and delivered nothing

The previous coding court was graded over 75 turns against a real problem. The result:

> **PASS as an IR grader. FAIL as a coding-agent court. Dest sats 0. The court never returned a file
> we compile.**

What it returned were constant-pool digests — 2, then 6, then 7 integers — and a `CALORIE` marker
beside them. Every one of those calls was, on its own terms, correct. The court compared LLVM IR
constant multisets and said whether they matched. It did that faithfully 75 times.

**And nothing in its output said it had not done the job.** Its single success marker could not
distinguish *"these two constant pools are identical"* from *"here is the artifact you asked for"*.
A caller reading `CALORIE_CODE_IR_EQUIV` had no field to check that would have revealed the gap.

Three probes from that game, all measured:

| call | result |
|---|---|
| `emit_source` | `-32601` — method not found |
| `code_cite` | `-32601` |
| `code_compile` | `-32601` |
| `code_ir_equiv` with `left_file` | `REFUSED_MISSING_ARG` |

The court could not be *asked* for source, and refused the only argument shape that would have
carried a file.

**That is the defect this architecture is built against**, and the rest of this page is mostly the
consequences of taking it seriously.

---

## 2. The shape: three layers, one direction

```
  ARTIFACT INGESTION BRIEF  ──▶  AffineCodingCourtBrief     parse · refuse by name
        (the question)                     │
                                           ▼
  the agent's artifact      ──▶  AffineArtifactJudgment     rule · a ladder, not a coin
                                           │
                                           ▼
                                 AffineArtifactDelivery      seal · base64, digest-verified
                                           │
                                           ▼
                              execute_artifact_crucible      one headless MCP tool
```

Each layer refuses in its own vocabulary. Nothing downstream is reached until upstream is satisfied,
and every refusal names which of the twelve fields, which law, or which host is missing.

---

## 3. Ingestion: the brief is the question

The template is the founder's — four sections, twelve fields — and **this is the text the court recognises, byte for byte** (`AffineCodingCourtBrief.blankTemplate`). It matters: the court decides "unfilled" by matching these exact placeholder strings, not by the shape of angle brackets (a Swift generic `<T>` is a value, not a placeholder). An earlier revision of this page paraphrased the placeholders; a brief built from that paraphrase was measured on 2026-09-02 to answer `REFUSED_UNKNOWN_ARCHITECTURE` rather than `REFUSED_UNFILLED_PLACEHOLDER`, because the paraphrased slots were read as filled and the first check that could still refuse was the architecture. Copy this block, not a description of it.

```
================================================================================
AFFINE CODING COURT: ARTIFACT INGESTION BRIEF
================================================================================

[LANGUAGE GAME DEFINITION]
Purpose: <Define the exact physical transfer or topological lock required>
Win Condition (Exit): <What precise MCP WASM evaluation equals WIN>
Losing Moves: <Define the entropy to avoid (e.g., dynamic arrays, continuous math, floating point)>

[STRUCTURAL GOAL]
Manifold Target: <Specify the exact C4 x S4 logic partition being mapped>
Input Coordinates: <Define the exact memory limbs (e.g., 64-byte interleaved X||Y, 3 Int32 GridTelemetry)>
Execution Lock: <How the algorithm proves the void pass without loops or iterations>

[PAYLOAD SHAPE]
Target Architecture: <Select ONE: [Swift 6.4 ~Copyable] | [AArch64 SIMD Assembler] | [ESP32 Xtensa Bare-Metal] | [Rust no_std wasm32]>
File Structure: <e.g., Single .swift file, or .s assembler binary payload>
Memory Binding: <Define the exact UnsafeRawBufferPointer or Register allocation for ingestion>

[WASM MEMBRANE INTEGRATION]
Target Standalone WASM: <e.g., affine-assembler-kernel.wasm, qmt-court-verifier.wasm>
NATS JetStream Subject: <The IPC topic this artifact will read from/write to>
Integration Protocol: The artifact must compile offline, drop directly into the cell's execution directory, and interface with the standalone WASM via standard I/O byte streams without requiring Docker or a runtime interpreter.

================================================================================
AGENT EXECUTION ORDERS:
1. Do not narrate. Do not explain the math.
2. Output the requested [PAYLOAD SHAPE] inside a single code block.
================================================================================
```

Measured 2026-09-02 on the live apex: this exact block, unfilled, answers
`REFUSED_UNFILLED_PLACEHOLDER: [LANGUAGE GAME DEFINITION] 'Purpose' is still the <angle-bracketed> placeholder from the blank template` — the first slot, named, so the caller knows where to start.

**The fourth architecture is committed, not yet serving.** `[Rust no_std wasm32]` is the client shell — the one thing `CLAUDE.md` sanctions Rust for — and until 2026-09-02 a brief for `apps/AffineWasmIDE` or `apps/AffineWasmTerminal` had no honest value to declare, so the founder's own client crate had to be filed under Swift. The case exists at HEAD with the zero-float detector (`f32`/`f64`, float literals) and the stub detector (`todo!(`, `unimplemented!(`) applied to Rust payloads; the fleet binary answers `REFUSED_UNKNOWN_ARCHITECTURE` for it until the next roll. A filled brief for the generic client is at `court-client.brief.txt` — see [the Court Client](Affine-Court-Client-Template.md).

**Why twelve fields and not a prompt.** Each field removes a degree of freedom that the artifact
would otherwise inherit. An unstated memory binding is a memory binding the agent chooses. An
unstated architecture is one it infers. The brief is not paperwork; it is the entropy the court
exists to remove *before* generation rather than detect afterwards.

### The refusals, and why there are six

| status | meaning |
|---|---|
| `REFUSED_NO_BRIEF` | prose, not a brief — no win condition, so nothing could be delivered against it |
| `REFUSED_MISSING_SECTION` | names which of the four |
| `REFUSED_MISSING_FIELD` | names the field **and its section** |
| `REFUSED_EMPTY_FIELD` | declared with no value — worse than absent, because it reads as answered |
| `REFUSED_UNFILLED_PLACEHOLDER` | still the `<angle-bracketed>` template text |
| `REFUSED_UNKNOWN_ARCHITECTURE` | quotes what was sent, lists what is accepted |

One status for "malformed" would be the always-red half of the discrimination defect: a caller would
learn their brief failed and not which of twelve fields to fix.

### The bug this parser had, and what it teaches

The first implementation stripped `<...>` wrappers and kept the text inside, reasoning that a caller
might leave brackets around a real value. Measured against the founder's own blank template, **every
slot then parsed**: `<Define the exact physical transfer or topological lock required>` became a
non-empty `Purpose`, and the empty template sailed through as a valid brief.

The court would have delivered an artifact against a question nobody asked.

> **A validator whose happy path includes the input it exists to reject is the always-green defect in
> its purest form.**

Brackets now mean *unfilled*. `testBlankTemplateIsRefusedAsUnfilled` is the control arm, and
`testFilledBriefParses` is its opposite — either alone proves nothing.

---

## 4. Judgment: a ladder, not a coin

```
 7  CALORIE_AFFINE_ARTIFACT_DELIVERED   every check passed; the artifact IS the verdict
 6  ARTIFACT_ASSEMBLED_NOT_DELIVERED    well-formed, laws hold, but no toolchain here to build it
 5  ARTIFACT_WIN_UNVERIFIABLE           the Win Condition cannot be measured, so it cannot be won
 4  ARTIFACT_PROTOCOL_CONTRADICTED      the link line contradicts the brief's own Integration Protocol
 3  ARTIFACT_TARGET_ABSENT              the WASM target, or an invoked export, does not exist
 2  ARTIFACT_LAW_BROKEN                 a Losing Move — or an Affine Constraint — is present
 1  NOT_KNOWN                           the court cannot decide with what it has
 0  REFUSED_*                           the brief is not a brief
```

`qmt_verdict: WIN | MISS` is still emitted for callers who want one bit — **derived from the rung,
never the source of truth.** Collapsing five states into MISS is what made the old court useless.

### Master of things affine: law that holds unasked

Checking only the brief's declared Losing Moves makes a linter that happens to read a template. A
brief that forgets to ban floats would get floats certified. The Constraints are not preferences a
brief may decline — they are the conditions under which nine cells agree at all:

| law | detected |
|---|---|
| **Constraint 3** — zero floats | `Float` / `Double` / `CGFloat` / `Float32` / `Float64` in a Swift payload |
| **Constraint 4** — no stubs | `fatalError` / `TODO` / `unimplemented` — code-shaped lies that compile and do not compute |
| **Constraint 5** — determinism | `.random` / `arc4random` / `Date()` / `clock_gettime` / `rdtsc` |
| **LAW 4 / 9** — no classical search | unbounded scans to `UInt32.max` and siblings in the substrate path |

**Scoped honestly, in the finding itself.** These are source-text detectors. They are blind to
implicit ARC boxing, existential containers, closure capture and Array copy-on-write — the same blind
spots the no-heap ratchet documents about itself. A clean result reads *"nothing detectable"*, never
*"proven compliant"*.

### `ret` is exempt, and that exemption is the whole discipline

`ret` assembles to `br x30`. It **is** a branch. A brief banning "branching instructions (b, bl,
cbz)" therefore condemns, read strictly, every leaf function ever written — including the artifact
that shipped with the brief.

A law-checker that reports the correct artifact as a violation gets muted. Once muted, the real
violations are invisible too. So `ret` is exempt **by name, with the reason recorded**, not by the
checker quietly declining to look — and `testRealBranchDoesFireTheDetector` proves a genuine `b` or
`cbz` still fires.

---

## 5. Worked example: the court reproducing a hand review

A real brief and artifact were submitted on 2026-08-31. The assembly was **correct**:

```asm
.global _map_s4_bounds
.p2align 2
_map_s4_bounds:
    ld1 {v0.2d, v1.2d, v2.2d, v3.2d}, [x0]
    ret
```

Measured: assembles clean, 2 instructions, 8 bytes of code. The *integration line* shipped with it
did not survive contact:

```bash
clang -arch arm64 -O3 -c nats_s4_ingest.s -o nats_s4_ingest.o \
  && cat nats_s4_ingest.o | wasmtime run --dir=. AffineWasmClient.wasm --invoke process_s4_stream
```

| claim | measured |
|---|---|
| the `.s` assembles | ✅ 2 instructions, 8 bytes |
| `AffineWasmClient.wasm` exports `process_s4_stream` | ❌ **0 occurrences** — no `s4_stream` symbol at all |
| `wasmtime` on a cell | ❌ ABSENT (also `wasmer`, `wasm3`) |
| `clang` on a cell | ❌ ABSENT (also `ld`, `gcc`) |

Plus: `wasmtime` **is** a runtime interpreter, which the brief's own Integration Protocol forbids;
`cat x.o | wasmtime` pipes AArch64 machine code into a WebAssembly runtime — different instruction
sets, and the bytes are an ELF container with headers and relocations, not a payload; `-c` never
links; and "single CPU cycle" is not measurable by any cell, since a 4-register `ld1` is multi-µop on
every real core.

**The court now finds all of that automatically.** `AffineArtifactJudgmentTests` asserts each one.
If it could not reproduce that review, it would be a formatter with a verdict field.

---

## 6. Delivery: the artifact travels as bytes, verified

JSON-RPC carries text; artifacts are bytes; base64 is the bridge.

```json
{
  "content": [
    { "type": "text", "text": "WIN. 371 bytes sealed, sha256 a3f2…" },
    { "type": "resource",
      "resource": {
        "uri": "affine://artifact/nats_s4_ingest.s",
        "mimeType": "application/octet-stream",
        "artifact_kind": "executable.static",
        "sha256": "…",
        "byte_count": 371,
        "blob": "<base64>"
      } } ]
}
```

**`blob`, not `text`.** MCP defines `text` for textual contents and `blob` for base64 binary. A
client reading binary under `text` may write it verbatim — producing a file of the right length and
the wrong bytes. Source still travels as `text`, where the content genuinely is text.

### The kind is declared, never sniffed

| kind | runnable on a cell today? |
|---|---|
| `source` | no — the cells have no compiler, by design |
| `object.relocatable` | **no** — needs a linker; `ld`, `clang`, `gcc` all ABSENT |
| `executable.static` | **yes** — write, `chmod +x`, run. No linker, no runtime, no interpreter |
| `wasm.module` | no — `wasmtime`/`wasmer`/`wasm3` all ABSENT |

A receiver that guesses would `chmod +x` an object file and hand back something that cannot execute.
`executable.static` is the shape that works with what is actually installed: **compile *and link*
offline, ship the linked ELF.**

### A prebuilt module may be posted — and that is how the top rung is reached

The crucible accepts two payload shapes in the same `artifact` field. **Source text** is judged line by line — Losing Moves, Constraints 3/4/5, LAW 4/9 — and, on a cell with no toolchain, caps at `ARTIFACT_ASSEMBLED_NOT_DELIVERED` because the court will not certify a build it never performed. **A compiled module** arrives as base64: the court walks the wasm section table (magic `00 61 73 6d`, version 1, every `(id, LEB128 length, payload)` consuming the bytes exactly), seals the bytes, and returns them as an MCP `resource` with `blob`, `mimeType application/wasm`, `artifact_kind wasm.module`, `byte_count` and `sha256`. Four bytes of magic and a length floor were the first gate; `00 61 73 6d FF FF FF FF` passed it and reached rung 7, so the gate became the section walk.

What the court says about a posted module is exactly what it can know: `law_checked false`, with a `source_law_checked` finding that reads *"NOT a violation and NOT a pass — nothing was scanned"*. Scanning the binary for floats would condemn every Swift-compiled module for the stdlib's own `f64` opcodes — always-red facing the other way — so the law is decided over SOURCE, in a second call, and the module is certified as a **structurally valid module, sealed byte-exact**.

Measured on the live apex 2026-09-02, from a browser page, with the served 4,946-byte `affine_wasm_ide.wasm`:

| step | measured |
|---|---|
| `execute_artifact_crucible` | rung **7** `CALORIE_AFFINE_ARTIFACT_DELIVERED` · `law_checked false` · `fits_one_nats_message true` |
| resource | `affine://artifact/affine_wasm_ide.wasm` · `application/wasm` · `wasm.module` · 4,946 B · sha256 `b9cabda18a55a10e…` |
| receiver re-digest | equals the declared sha256; bytes identical to the posted module |
| malformed control | `00 61 73 6d FF FF FF FF` is NOT sealed as a module; it falls through to the source path and answers `ARTIFACT_ASSEMBLED_NOT_DELIVERED` |
| instantiate + drive | imports `box_camera.project_x/y` resolved; `validate_edge_code → 1` over a 110-byte prompt; `ingest_intent_vector` accepted under a monotonic sequence id; 725 lit pixels painted on a 600×600 canvas |

The receiving page is [the Court Client](Affine-Court-Client-Template.md) — the generic wasm IDE client that runs every court tool, turns local files into language games, and loads what the crucible returns.

### Transport ceiling

NATS `max_payload` measured **1,048,576** bytes — the unconfigured default, set nowhere in
`nats.conf`, reported by the server's own `/varz`.

| artifact | bytes | base64 | one NATS message? |
|---|---|---|---|
| `affine_wasm_ide.wasm` | 4,946 | ~6.6 KB | ✅ |
| `affine_wasm_terminal.wasm` | 3,888 | ~5.2 KB | ✅ |
| `AffineWasmClient.wasm` | 12,347,843 | ~16.5 MB | ❌ 16× over |
| `GymWasmClient.wasm` | 16,106,726 | ~21.5 MB | ❌ 20× over |

A bundle reports which transport applies **before** publishing, because a broker rejection arrives
far from the code that decided to send.

---

## 7. Headless: one tool, two paths

```bash
curl -sS -X POST https://affine.earth/language-invariant/mcp \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{
        "name":"execute_artifact_crucible",
        "arguments":{"brief":"<the full brief block>","artifact":"<the source>"}}}'
```

A CI runner, a curl script, an autonomous agent and a human's editor all post **the identical**
`tools/call`. Nothing in the dispatch can tell which called it.

> Enforcement lives at the API layer, never in a frontend, **because a frontend cannot bind a caller
> who does not use one.**

No IDE is shipped in the payload. Anyone calling the court is already an MCP client by definition, so
shipping a workbench would be handing a tool to someone who necessarily has one — and creating a
second surface to hold in parity with the court's own rules.

### The brief is the single home for the architecture

`target_architecture` may be passed, and if it contradicts `[PAYLOAD SHAPE]` the call is
`REFUSED_ARCHITECTURE_CONFLICT` — never silently overridden. Two copies of one value that can
disagree, with no rule for which wins, is a hop.

---

## 8. Two defects found in this court, by adversarial review

Recorded because the failures are more instructive than the design.

**The tool was advertised and could not be called.** `execute_artifact_crucible` was declared in
`CapabilityRegistry` and given a `case` in `AffineContextMCPTools` — and left out of the outer
dispatch predicate, which names its tools by literal. `tools/list` advertised it; every call fell
through to `-32601 Unknown tool`. **Exactly** what `emit_source` did in the 75-turn game: a name in
the catalogue with no arm in the dispatch. Adding a tool means both ends, and the advertisement is
the half that lies convincingly.

**The court was always-red, and a test defended it.** `guard host.supports(...)` ran *before* the
judgment. A production cell declares every build capability false — correctly; it has no toolchain —
so every well-formed brief returned `REFUSED_NO_CRUCIBLE_HOST` and the eight-rung ladder never
executed once.

> A court with eight rungs that can reach zero of them is the same defect as one that always passes.
> Only the direction differs.

The repair is a distinction, not a flag: **"can I build this?" and "can I judge this?" are different
questions.** Judging is a pure function of bytes — the property that lets nine cells agree — and needs
no compiler. Building is host-dependent. The host now selects the *ceiling rung*; it does not gate
the verdict. `REFUSED_NO_CRUCIBLE_HOST` survives for one case only: the caller explicitly asked for a
build.

---

**An advertised argument shape was deleted before the court could read it.** `code_ir_equiv` advertises three input shapes — `left_file`+`right_file`, a two-element `files` array, and the legacy `left_ir`/`right_ir` fragments — and `CodeCourtWholeFile.parsePair` accepts all three. Measured 2026-09-02 on every one of the nine cells: the `files` array answered `REFUSED_MISSING_ARG`, always. The membrane strips a fixed list of *elephant keys* (raw context that must never ride the ledger: `text`, `content`, `prompt`, `files`, …) from every `tools/call` before the tool body sees it, and `files` is on that list. Three correct parts — description, schema, parser — and one strip that ran first. The parser-level tests could not see it because they drove `codeIREquivTool` directly, the half that was never broken. Repair at HEAD: an argument the tool's own registry schema **declares** is not an elephant, and the exemption is read off the schema so a declared key cannot silently re-open the gap; a membrane-level test drives the full JSON-RPC path with control arms (`files` is still an elephant key; `membrane_health` does not declare it; exactly one served tool declares an elephant-named argument). **Committed, not yet serving** — the fleet answers `REFUSED_MISSING_ARG` for `files` until the next binary roll; `left_file`/`right_file` work today and are the shape to use.

---

## 9. What is proven, and what is not

**Proven — 119 tests, 0 failures**, across brief parsing, judgment, crucible and delivery. Both arms
of every detector: the blank template refuses *and* a filled brief parses; `ret` does not fire *and* a
real branch does; `FloatingHeader` is not a float type *and* `var scale: Double` is; a bare cell
judges *and* an explicit build request there refuses.

**Measured on the live fleet:** nine cells, one binary sha, `max_payload` 1,048,576, no
compiler/linker/wasm-runtime on any cell, `AffineWasmClient.wasm` exporting no `s4_stream` symbol.

**LIVE — measured per cell 2026-09-02.** `execute_artifact_crucible` is the 49th name on `tools/list` on every one of the nine A records (SNI pinned; one name set, one sha of the sorted list on all nine), and it returns rungs on the apex:

| call | measured on the apex |
|---|---|
| the court's own blank template, unfilled | `REFUSED_UNFILLED_PLACEHOLDER` naming `Purpose` |
| prose, no brief | `REFUSED_NO_BRIEF` |
| a filled AArch64 brief + the 2-instruction `ld1`/`ret` artifact | `ARTIFACT_ASSEMBLED_NOT_DELIVERED · hasAssembler=false hasWasmRuntime=false` |
| the same brief with `target_architecture: Swift 6.4 ~Copyable` passed beside it | `REFUSED_ARCHITECTURE_CONFLICT` |
| a `cbz x0, 1f` under a brief that bans branches | `ARTIFACT_LAW_BROKEN · losing_moves_absent: branch` |
| `var scale: Double = 1` under a Swift brief | `ARTIFACT_LAW_BROKEN · Constraint 3 (zero floats)` |
| a clean `~Copyable` struct under a Swift brief | `ARTIFACT_ASSEMBLED_NOT_DELIVERED` (no toolchain on a cell, by design) |
| the served 4,946-byte `affine_wasm_ide.wasm`, base64 | rung **7** `CALORIE_AFFINE_ARTIFACT_DELIVERED`, returned as a `wasm.module` resource, sha256 re-digests to the posted bytes |

The earlier text of this section — *"committed but not serving … not yet callable on the apex"* — was true on 2026-08-31 and is retired here with the measurement that retired it.

**Committed, not yet serving, as of this measurement:** the `Rust no_std wasm32` architecture (§3), the `files` array shape for `code_ir_equiv` (§8), and the corrected description of `project_affine_key`'s reverse face. Each answers the older way on the fleet until the next binary roll, and each is named here so a reader can tell the two states apart.

**Deliberately not claimed:** that a certified artifact compiles, that it passes wasm validation, or
that it runs. The court certifies the *source* and says so. Certifying a build it never performed is
the fraud the whole ladder exists to prevent.