# OMNASCRIPT — the family filing of OMNASCRIPT-SPEC v0

> Provenance: this is Part II of `~/workspace/nomos-gym/voxel-gym/OMNIX-GYM-SCOPE.md`,
> extracted byte-for-byte at founding (2026-11-11). The scope document carries
> Part I (the Omnix gap analysis) and the running proof record; this filing is
> the spec as the family keeps it. Amend both or neither.

# OMNASCRIPT-SPEC v0 (FOUNDING RECORD)

## §1 Founding

**OmnaScript** is founded 2026-11-11 by founder ruling, in the founder's
language family, as a sovereign source language that **compiles to
JavaScript**. Omnix contributes the grammar skeleton and the discipline;
JavaScript contributes the runtime semantics and the reach. Its first
compiler is `omnascript.cjs` (zero dependencies, no eval, deterministic
codegen); its **Program #1** is the voxel gym's brain — a language is born
when a real program runs in it. Family filing:
`~/workspace/kernel-collection/n8-kernels-and-languages/languages/omnascript/`
— its CATALOG entry is **drafted, awaiting ratification by the language
seat**; nothing in this spec canonises itself.

## §2 What Omnix contributes (each item cited to its record)

1. **The surface**: a version header line (`omnix 2` → `omnascript 0`);
   line-oriented declarations; named blocks closed by `}`; `field value`
   lines inside blocks; `#` comments. (v2 parser, passim.)
2. **Closed vocabularies**: kinds, ops, gates and backends are closed sets
   and unknown words fail closed. OmnaScript closes its own sets the same
   way: host primitives, strategies, novelty kinds, rungs, trigger forms.
3. **Shares that must sum**: material weights sum to 1 in v2 → family
   weights sum to 100 in OmnaScript; any other total refuses.
4. **The deterministic gate is required** (v2: no compile without it).
5. **Proposer ≠ reviewer**: the agent seats come as a distinct pair or not
   at all (v2 semantic law).
6. **Dependency DAGs, acyclic, checked at compile** (v2 stages → OmnaScript
   instrument `after` references).
7. **Canonical serialisation + sha256 provenance** for source and IR
   (v2's `canonical()`/`sha()`, inherited, not forked in spirit — the
   OmnaScript compiler carries the same functions under the same law).
8. **Fail-closed errors with line numbers**, and the guide's standing rule:
   *no silent unsupported features* — a declaration must execute or refuse
   (START-HERE working agreement, rule 5).
9. **Declarations name operations; the runtime owns the mathematics** —
   v2's `op height` never contains the heightfield's arithmetic. OmnaScript
   §4 is built on exactly this division.

## §3 What JavaScript carries

1. **Execution semantics**: arithmetic, the seeded PRNG (mulberry32),
   state (maps/sets), and control flow exist only in compiled output and
   the versioned runtime law — never in source.
2. **The host surface (interop contract)**: compiled policy code may touch
   the world only through a declared `env` — `chunkKey()`,
   `hotbarNames()`, `selectedName()`, `appendGoal(rec)` — supplied by the
   host. Compiled instruments read trajectory records as data. Nothing
   else is reachable; a compiled program cannot import, eval, or wander.
3. **Targets**: `node` (CommonJS module) and `browser` (a
   `window.__OMNA_BRAIN__` / `window.__OMNA_INSTRUMENTS__` bundle). The
   same source compiles to both; both outputs carry the source sha256.

## §4 Semantics — the runtime law (versioned with the language)

Source declares intent and parameters; the following laws live in the
compiler's runtime (`omnascript-rt-0`, inside `omnascript.cjs`) and change
only by spec amendment:

- **Strategy `weighted-novelty`** (the only strategy in v0): a goal lasts
  `goal-span` actions (inclusive). At goal choice, with probability
  `curiosity` the family is the argmax of novelty scores; otherwise it is
  drawn by family weights. Novelty is computed **only from a family's
  declared `prefer` kinds**, by these formulas: `unvisited-chunk` →
  clamp(1.2 − 0.25·visits(here), 0.1, 1); `unplaced-type` → unused types
  remain ? 0.55 + 0.15·unused : 0.3; `untried-verb` → 0.3 + 0.2·untried
  (untried counted over the policy's declared `probe` set). A family
  declaring no `prefer` scores a flat 0.45. Within a goal, verbs draw
  uniformly from the family's verb list (repetition weights the draw, as
  in the gym's original lists). If the chosen family declares
  `unplaced-type` and, with probability `curiosity`, the drawn verb is not
  a fresh placement, the policy selects the next unplaced type instead
  (`select_next`). These formulas reproduce, number for number, the
  novelty mathematics of the JS ExplorerPolicy they replace; the
  *declarations* are what moved into OmnaScript.
- **Instrument triggers**: evaluated over a session's `verification`
  records in order. `edit place|break [blocks …]` — first edit of that
  kind (optionally of the named blocks); `streak` — first run of *n*
  consecutive edits of a kind (an edit of the other kind resets it);
  `distance beyond n` — first record whose `ctx.distSpawn` exceeds *n*;
  `distance within n after <instrument>` — first record inside *n* after
  the named instrument has fired; `height above-spawn n` — first record at
  least *n* above the session's first recorded height. Instruments with
  `watch page` (triggers `in-water`, `look-sum`, `selections`) are
  *defined* in source but *observed* by the page, because yaw, the
  selection wheel and the block at his feet are not trajectory fields —
  the source says where its evidence comes from rather than pretending.

## §5 Grammar (v0, complete)

```ebnf
program     = "omnascript 0" NL decl*
decl        = "program" name | "seed" uint
            | "agent" ("proposer"|"reviewer") name
            | "gate" "deterministic"
            | vocabulary | family | policy | instrument
vocabulary  = "vocabulary" "{" NL ("verb" name hostprim NL)* "}"
family      = "family" name "{" NL familyfield* "}"
familyfield = "weight" int0-100 | "verbs" namelist
            | "prefer" noveltylist | "text" rest-of-line
policy      = "policy" name "{" NL policyfield* "}"
policyfield = "strategy" "weighted-novelty" | "curiosity" num0-1
            | "creed" rest-of-line | "families" namelist
            | "probe" primlist | "goal-span" int int
instrument  = "instrument" name "{" NL instfield* "}"
instfield   = "label" rest-of-line | "rung" ("creative"|"tools"|"survival")
            | "status" ("active"|"dormant") | "watch" ("trajectory"|"page")
            | "trigger" trigger
trigger     = "none" | "edit" ("place"|"break") ["blocks" blocklist]
            | "streak" ("place"|"break") int
            | "distance" "beyond" num
            | "distance" "within" num "after" name
            | "height" "above-spawn" num
            | "in-water" | "look-sum" num | "selections" int
```

Semantic law beyond the grammar: one program per file carries **either** a
policy **or** instruments, never both (one program, one job); a policy
program requires a vocabulary; every declared family is governed by the
policy and every governed family is declared; dormant instruments declare
`trigger none`, active ones may not; source is bounded at 65536 characters
(the v2 bound).

## §6 The compilation contract

1. **Determinism**: the same source compiles to byte-identical output on
   any machine. No timestamps, no environment reads, no randomness in
   codegen. (Tested.)
2. **Provenance in the artifact**: every output opens with a generated-file
   banner carrying program name, kind, source filename, **source sha256**
   and **IR sha256**. Generated files are never edited by hand; the source
   is the artifact of record.
3. **Refusal before emission**: a program that violates any law of §2/§5
   produces **no output file** — the compiler fails closed, in the v2
   manner.
4. **The trajectory header law** (gym binding): a session flown by an
   OmnaScript brain chains a `brain` record immediately after
   `session_start`, naming language, program, source sha256 and IR sha256.
   A session without that record is a JS-brain session; the record is how
   the log tells the two apart.

## §7 Errors speak OmnaScript

Every refusal is one line — `omnascript: <file>: line <n>: <message>` —
naming OmnaScript constructs (program, family, vocabulary, instrument,
gate), never a JavaScript exception, never a stack. Real refusals from the
compiler's own test suite:

```text
omnascript: gym-brain.omna: line 33: family "explore" names "smash", which is not a name OmnaScript allows
omnascript: gym-brain.omna: line 62: the family weights sum to 95, but shares of one mind must sum to 100 — inherited from Omnix, where material weights sum to 1
omnascript: gym-brain.omna: line 13: proposer and reviewer are the same name ("nomos") — no mind grades its own work in this family
omnascript: test.omna: line 1: an OmnaScript program opens with "omnascript 0" — Omnix authors, JavaScript carries
```

## §8 The frontier debt, labelled

- **The renderer is not OmnaScript's.** The gym's world renders through the
  existing JS/WebGL shell. Omnix's own road to a renderer (v2 bridge →
  Polycedral3D) is soil-only, CPU-reference, and its dialect integration
  into JinX3D is PR #6's blocked frontier. OmnaScript claims none of it.
- **The engine is not OmnaScript's.** Physics, meshing, the day cycle and
  the trajectory chain remain the gym's JS — they are the *host*, under
  §3's contract, exactly as `day_color.py` remained the presentation
  dialect's host stage.
- What moved is the **brain and the instruments**: the parts of the gym
  that are *decisions and definitions* — the parts that are Nomos.

## §9 Limits of v0 (filed, not discovered later)

- No expressions, no user-defined strategies, no conditionals in source:
  behaviour is declared parameters over versioned runtime law (§4). A
  future version that wants source-level logic must amend this spec, not
  smuggle it.
- Family `weight` steers only the non-novelty branch in v0; the novelty
  branch is pure argmax, as the replaced policy behaved.
- Page-watched instruments are definitions whose observation stays with
  the page until the trajectory grows yaw/selection/feet fields.
- One world, one host surface: the `env` contract is the voxel gym's.
  A second host (the remaster's playthrough) is a new contract, filed
  when it exists.

## §10 Program #1 and status

- **Program #1**: `voxel-gym/omnix/gym-brain.omna` (policy) +
  `gym-instruments.omna` (learning instruments) — declaration-for-declaration
  the mind and the measuring sticks that flew the gym's first night, now
  authored in OmnaScript. Compiled outputs, the proof driver and the proof
  session live beside them in `voxel-gym/omnix/`.
- **Compiler**: `languages/omnascript/omnascript.cjs` (canonical), vendored
  byte-identical into `voxel-gym/omnix/` (sha-pinned by its test suite).
- **Tests**: `languages/omnascript/omnascript.test.cjs` — 8/8 green at
  founding (determinism · both programs compile · policy determinism ·
  instrument derivation · refusal voice · **browser-bundle global-scope
  isolation** — the regression named in the receipt · vendor identity).
- **Status at founding**: *verified as the gym's live policy* by the
  §II-PROOF session (chain-verified, header law held, control-run
  equivalence); comparative firsts on a healthy world remain blocked on
  the gym page/world layer named in §II-PROOF.

## §II-PROOF — the first session flown by an OmnaScript brain

**Run** (HOST evidence): `voxel-gym/omnix/run-omna-session.cjs`, 2026-11-11.
The driver compiles `gym-brain.omna` fresh (source sha256
`784743845bac…`, IR sha256 `61bf16f1651d…`, browser bundle sha256
`4ad6d3c89aad…`), injects it before the page's first frame, and the
installer swaps the policy at that frame — after `session_start` is
chained, before any tick. The trajectory header reads exactly as §6.4
requires: **seq 0 `session_start`, seq 1 `policy`** naming language,
program and both hashes. The session flew 323 actions at the 50× clock on
a genesis world (`.omna-profile`, seed 20261110); the full trajectory
(396 records) **verifies under gymlib**, and the compiled instruments'
`deriveFirsts()` read it without error. Goal families across 66 goals:
build 53 · learn 5 · destroy 4 · explore 4. Page-fired milestones:
**first_palette @ action 9 · first_look @ action 107**. Raw artifacts:
`voxel-gym/omnix/proof/` (`session-omna-1.jsonl`, `PROOF-session.json`,
driver logs).

**The honest complication, with its control run.** This session placed 0,
broke 0, and never left spawn (maxDist 0) — the same stall the overnight
JS record shows from session 10 onward. To isolate brain from world, the
lane ran a **control**: the stock JS policy, the same current page, a
genesis world, no injection (`proof/diag-js.log`). Result: 133 actions,
**first_palette @ 9, first_look @ 107 — the identical milestone
signature** — and likewise 0 placed, 0 broken, maxDist 0. The position
trace in the OmnaScript session is frozen at the spawn centre
(96.5, ~18, 96.5) across all 325 verifications while y oscillates
18.0–19.0: jumps fire and gravity lands him; horizontal drive and the
reach-7 raycast find nothing in any facing. **The stall lives in the
gym's page/world layer at genesis** (a spawn-pocket or drive-path
condition in the current page build — the evolved overnight world and
earlier page state are where JS sessions 5 and 7 earned first_place @ 14
and first_break @ 26), and it binds both brains identically.

**What the proof therefore establishes, and what it does not:**
- ESTABLISHED: an OmnaScript program *is* the gym's policy in a live,
  chain-verified session — decisions, goals, curiosity and novelty values
  in the trajectory are the compiled program's; under identical
  conditions its behaviour signature is indistinguishable from the JS
  brain it replaces, milestone for milestone.
- NOT ESTABLISHED: comparative firsts/rates on a healthy world. That
  comparison is **blocked on the gym page/world layer**, named above with
  its control-run evidence, and belongs to the gym lane's bench (its
  detail-refinement pass is editing this same page). When the world
  moves again, re-running `run-omna-session.cjs` against the JS baseline
  sessions is a one-command re-proof; the driver and this section are
  built for exactly that.

---

## Amendment A1 — the hands kind (2026-11-11, GOOD HANDS storey 1)

OmnaScript gains a third program kind beside policy and instruments:
**hands**. A hands program declares the body's skilled movements; the
geometry of performing them is runtime law in the compiler, as the
policy runtime is for the brain.

**Grammar.** A `hand <id> {}` block declares `act` (place | break),
`mode` (cell | column | row | dig), `attempts` (1–40, required — a
hand without a budget is a wish), `reach` (optional, ≤ 7, default 7),
and a `text`. A program is exactly one kind: a hands program declares
hands and binds the whole verb vocabulary, and refuses in
OmnaScript's voice otherwise. The IR carries hands lazily, so policy
and instruments programs keep their founding canonical bytes — the
gym-brain's IR sha is unchanged by this amendment (the founding test
suite pins it).

**The five modes.** cell: one named cell. column: a vertical stack
from a named base cell, placed from beside it (the top levels by a
risen aim — see below). row: a horizontal run from a named cell along
a declared direction. dig: breaks the support under his own feet,
`length` levels down, each cell read from the body as he descends.

**Runtime law (the aim solver).** Hands run through an env contract —
pose() · target() · blockAt · isSolid · hotbarNames · selectedName ·
appendTask — and are deterministic: same world, same next primitive.
Per cell the solver: plans a stance (sixteen ring points, kept only
if the body fits with support underfoot, scored by whether the
straight walk is blocked at body height — walking into an obstacle
and pushing is refused as a strategy); approaches it; selects the
declared block; aims with the host's coarse look steps, serving
whichever error is large *for its own step* and treating half a step
as aligned, then probing the four single-step neighbours; and acts
only when the host's own crosshair **verifies** — the raycast target
equals the intended support cell and face (for break: the intended
cell itself). Every act's verdict returns through observe() and is
counted; a cell lands only when the host's edit record names it.
Cells the host's entomb guard protects (his own feet/head cells) are
filled mid-rise: aim nearly straight down first, jump, act only while
risen past the guard. Supports whose top face sits above the standing
eye are placed the same way, pre-aiming for the *risen* eye (~1
higher) with a one-step deadband. All task events (task_start ·
cell_done · cell_fail · task_done) carry `agent: 'nomos'` — per-agent
attribution is a trajectory requirement, not a garnish.

**Header law.** A session flown by hands names the program in its
trajectory exactly as the brain does: a record carrying the program
name, kind `hands`, source sha256 and IR sha256, in the session's
first records.

**First citizen.** `gym-hands.omna` (voxel gym): place-at-target ·
break-at-target · pillar-up · wall-row · step-down. Its conversion
proof is filed with the GOOD HANDS receipt in the gym tree; the
compiler's own suite carries a fake-host conversion test for all
five hands.

**A1.1 (same day, from the target test's own evidence).** Three
rulings the first browser battery forced, each with its receipt in
the GOOD HANDS lane's records: (1) a cell whose end-state already
holds (breaking air, placing a block the cell already holds) closes
at once with `already: true` in its record — breaking air can never
lock a crosshair, and the grid itself is the verification. (2) The
hands expose `cancel(reason)`: a driver may abandon a task, and the
abandonment is a trajectory record, never a silent disappearance.
(3) Stance discipline: anywhere inside the aim band is a working
stance (a movement primitive's drive window is wall-clock, so under
load one step carries several blocks and a precise point is a trap);
a stance that failed a cell is not retried, nor is its whole side
of the cell — a neighbour placed earlier can occlude the supports
from one side only — and a cell gets up to three stances before it
is filed as failed.

---

## Amendment A2 — the launcher kind (2026-11-11, the conversion)

OmnaScript gains a fourth program kind beside policy, instruments and
hands: **launcher**. A launcher program carries every *decision* of a
launch — founded by the conversion of the founder's T-Launcher
specimen (census: `SPECIMEN-CENSUS.md` in this directory) into the
family's own tongue.

**Grammar.** One `launcher {}` block per program, and a launcher
program is only a launcher (one program, one job, as ever). Fields:
`minecraft` (dotted version, pinned) · `manifest` (the https URL of
Mojang's piston-meta version manifest) · `username` (3–16, the game's
own rule — the offline session's name) · `java` (level, 8–25) ·
`memory` (heap MB) · `verify` (closed set: `sha1`) · `natives`
(closed set of platforms) · `entry` (`server` | `title`) · `server` +
`port` (required when entry is server) · `game-dir` (workspace-relative
path, no `..`) · `mod-loader` (closed set: `fabric`) +
`loader-version` (pinned, never "latest") · `controller-mod` +
`controller-version` (a pinned mod project and version; a mod without
a loader refuses) · `resource-pack` (the house pack's slot name) with
`resource-pack-state` (`awaiting-pin` | `pinned`); a pinned pack must
carry `resource-pack-sha1` + `resource-pack-source`, and an
awaiting-pin pack must carry neither — one state, one story. `text`
as elsewhere.

**The division of labour (the §2.9 law, applied).** Source declares
decisions; it never contains an artifact URL or a download hash —
those are facts the official metadata carries (piston-meta for the
game, the loader's maven checksums for Fabric, the mod host's file
hashes for mods), and the executor pins them into a filed launch plan
at provision time. The compiled output exports `createLauncherPlan()`:
the declaration verbatim, plus the provenance meta (source sha256 ·
IR sha256).

**The executor contract.** A launcher's host (the reference executor
is `launcher-executor.cjs`, beside the examples) performs only the
effects the plan names, in two sealed phases:

- **Provision** (the only network phase, invoked explicitly): resolve
  the declared version from the declared manifest; download the
  COMPLETE official artifact set (full-data law: every artifact the
  version metadata names — client, all libraries and classifiers, the
  full asset index — never a subset), plus the pinned loader and mods;
  verify every artifact against the sha1 its official metadata
  carries; a mismatch refuses the whole provision, fail-closed, and
  the refused bytes are deleted. Write the launch plan: every
  artifact with its hash, size, source, and the program's provenance
  hashes.
- **Launch** (no network, by construction): read the filed plan,
  re-verify the local bytes against their pins (local reads only),
  assemble classpath and extracted natives, construct the offline
  session locally (username as declared; offline UUID derived from
  the name; access token `0` — no auth call exists in this design),
  write the launch configuration (including the resource-pack
  selection when the slot is pinned), and spawn the game. If the
  plan is absent or a pin fails, launch refuses — it never reaches
  for the network to repair itself.

**First citizen.** `examples/launcher.omna` — Minecraft 1.21.11 (the
real-Minecraft spike's pin) for the resident Nomos: Fabric 0.20.1,
Controlify 3.0.1+lts (the controller seat), the house resource-pack
slot awaiting its pin. Its provision + launch proof is filed in
`CONVERSION-RECEIPT.md` in this directory.

---

## Amendment A3 — the world kind (2026-11-11, the voxel core)

OmnaScript gains a fifth program kind beside policy, instruments,
hands and launcher: **world**. A world program declares a region of
voxel ground whole — its matter taxonomy, the field that sentences
its shape, its water, and its scatter rules — and the compiled core
carries the machinery a game would otherwise rent: storage,
checkpointing, meshing, chained editing, and the physics hooks.
Founded by the founder's ruling of 2026-11-11 16:59 EST ("Build it —
spec our own voxel core in OmnaScript"), against the Lay of the
Land study's proof that the reference game's voxel layer is the
commercial Voxel Plugin — a licensed commodity. The core's own
spec (API contracts, the language-surface reasoning, the Archive
path) is filed at `~/workspace/nomos-gym/voxel-core/SPEC.md`; this
amendment is the language's record of the kind.

**Why a kind, and not a library.** A JavaScript library would put
the world's decisions in hand-written JS wearing the language's
clothes — a violation of §2.9 (declarations name operations; the
runtime owns the mathematics) and of the family's founding division.
The voxel core's *configuration* (taxonomy, region, fields, scatter,
quantum) is declared parameters; its *behaviour* (genesis, meshing,
support) is versioned runtime law — exactly the shape of every kind
before it. The hands precedent carries the weight: A1 put a whole
aim solver in the compiler's runtime under declarations of act,
mode and budget. A3 puts a world under declarations of matter and
ground.

**Grammar.** Three block forms, one program one job as ever:

- `category <name> {}` — a matter category: `state` (closed set:
  solid | fluid | gas | fire — the reference build's material
  classes, STUDY §10 rule matter-material-classes), `mass`
  (per-cell, 0–10000), `rgb` (three channels — the category's
  identity at the picture layer), `text`. One declaration, read by
  physics, picture and keeper alike (BLEND-DESIGN §4.1).
- `region <name> {}` — exactly one per program: `size <x> <y> <z>`
  (each 1–96, at most 262144 cells), `quantum <k>` (1–8, default 4 —
  the settled grain, BLEND-DESIGN §4.5), `height <op>` (closed set:
  flat <level> | cone <base> <amp> | noise <base> <amp> <scale>),
  `fill` and `skin` (categories; skin defaults to fill), `water`
  (a category) with `water-level` (default 0), `biome` (default:
  the region's name), `text`.
- `scatter <name> {}` — placement rules as data (STUDY §10 rule
  scatter-per-biome-with-resources): `item` (closed set: tree |
  rock | shrub — every member of the set is implemented in the
  runtime; the set grows only with its implementations), `on`
  (the surface category), `of` (the planted category), `with`
  (a tree's crown category — trees require it, other items refuse
  it), `height <min> <max>` (trees only), `density` (0–1), `text`.

**Cross-checks (fail-closed, in the language's voice).** A region's
fill and skin must name declared categories of state solid; its
water must name a declared **fluid** (a level with no water refuses;
a solid named as water refuses — "water is a fluid or it does not
flow"); a scatter's categories must exist and be solid; a world
binds no vocabulary and no families — verbs and minds live in their
own programs. Category cross-checks inside the world kind are this
amendment's answer to the redesign's GAP-L1 in block form: the
category *construct* now exists and is cross-checked; a standalone
category program kind (a taxonomy filed detached from any world,
for the admission court's own filings) remains unnamed future work,
named here so the gap is a decision, not an oversight.

**Runtime law (omnascript-rt-0, A3 section).** `createWorld(env)`:
genesis evaluates the heightfield op per column and files the
**field sextet** — terrain_height · water_height · water_depth ·
biome · splat_01 · splat_02 (the reference world's storage form,
BLEND-DESIGN §3) — then fills the grid the fields sentence (fill
below, skin on top, water where depth > 0), then applies scatters
in declared order. **Checkpoint**: the sextet + the sparse delta
list + a grid digest, in canonical form; `verify()` re-derives the
fields and the genesis grid from the function alone, replays the
deltas, and compares digests — the checkpoint form of BLEND-DESIGN
§3 (function + sparse deltas; dense fine-field storage refused by
the study's arithmetic). **Meshing**: every solid cell's faces are
fragmented to the quantum first (k² micro-faces per logical face),
culled by the visibility law — a face shows if its neighbour is
air, or if it is a solid's face toward a fluid (the shore law: the
bed's face is the shore surface; a fluid's face toward a solid is
never drawn) — then greedily merged over compatible micro-faces,
with the ledger kept (generated → visible → merged → tris), the
vista line's generation-before-merging order (BLEND-DESIGN §4.5).
**Edits**: `edit({kind: break | place | chip, at, category?})`
mutates the grid, appends a sparse delta, and emits a chained
record through `env.appendRecord` when the host offers it. A3's
honesty on chip: at this grain chip erodes a whole logical cell —
sub-cell erosion is the field kernel's next layer (BLEND-DESIGN
§4.3 files the GOOD HANDS break verb as chipping's coarse ancestor;
the core's chip is the same relation one grain down). **Physics
hooks**: `cellAt`, `massAt`, `component` (connected solid mass —
cells and mass sum), `support` (an unbroken mass path to y=0
exists — the redesign's support rule, DESIGN §7.1, as a query;
collapse *resolution* is Storey 5's solver work, not this kind's).
**Determinism is constitutional**: all randomness is mulberry32
streams seeded by (program seed, scatter name, scatter index);
crown corner-trimming is by position hash (the vista discipline);
iteration is index order throughout; no clock, no Math.random, no
environment read reaches the grid. A world's records carry no
timestamps — a chain over them is a pure function of seed +
declarations + edits (the host's ledger may stamp time at its own
layer, as gymlib does).

**Header law.** A session flown by a world names it exactly as the
brain and hands are named: creation emits a `world_define` record
carrying program, kind `world`, region, source sha256 and IR
sha256, through the host's appendRecord when offered.

**First citizen.** `examples/island.omna` — one cone island
(24×18×24, quantum 4, water at level 4; five categories; trees,
rocks and shrubs by scatter), flown end-to-end by the smallest
proof at `~/workspace/nomos-gym/voxel-core/` (checkpoint verified,
one chained sever, support asked and answered, determinism proven
by regeneration — the proof's receipt is filed there). The
compiler's suite carries the kind's tests (compile + determinism ·
the checkpoint/sever/support proof · refusals · browser-bundle
isolation), 21/21 with the founding seventeen; the founding
programs' IR hashes are unchanged under this amendment (lazy IR,
as A1/A2 kept them).

**What A3 does not grow.** No coupling grammar on categories yet
(DESIGN §5.1's full declaration carries one; it is the taxonomy
court's next amendment, not silently absent — it is named here).
No awake scheduling (GAP-L4 stands: runtime law, not syntax). No
second region per program, no inter-region frontier, no keeper
verbs (GAP-L2 stands). The renderer is still not OmnaScript's
(§8): the core emits merged mesh data; hosts draw it.
