docs: the layer stack in verbs - the acceptance test for one engine

Gabriel's restatement recorded: L0 machine, L1 boundary store, L2
engine (Stf + Ruler), L3 positioning (machine_at), L4 the
computation facade, L5 the schedules - the only layer where the
runner and the hero differ. Two invariants promoted for step 4 to
be held to: the root claim is served from persisted material (the
hero reuses the runner's work product, not just its code), and a
machine collect never crosses a fed input boundary (crossing
belongs to positioning and idle replay; collect's mid-collect
feeding support should shed in step 4). The epoch lifecycle and the
react layer stay outside the shared machinery, deliberately.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: GCdePaula

docs/plans/one-engine.md

@@ -123,6 +123,44 @@ verbs - regime 1 already re-clones, regime 2's feed already commits
 the boundary; unify on clone-based restore); the third and fourth
 padding implementations.
 
+The layering, as Gabriel restated it in verbs (2026-07-14, recorded
+because it is the acceptance test for step 4's shape):
+
+- L0 the machine: load/store/clone/run (the bindings).
+- L1 the boundary store: checkout/commit/nearest (snapshots.md).
+- L2 the engine: Stf (one machine's verbs; feed carries the payload
+  lookup and the checkpoint) + Ruler (geometry: advance, collect,
+  prove_transition).
+- L3 positioning: machine_at = nearest + advance + write-back.
+- L4 the computation facade: node/children/leaf proofs = the
+  persisted tier (seeds today, window roots after step 3) + the
+  quartet cache + L3.
+- L5 the schedules - the ONLY layer where the runner and the hero
+  differ. Runner: forward, one window at a time, persisting as
+  final. Hero: on demand, wherever the opponent points (its three
+  verbs: root for the claim, children for the bisect, prove for the
+  step).
+
+Two invariants this framing surfaces, to hold step 4 to:
+
+- The root claim is served from persisted material, machine
+  execution only below persisted coverage. "Same machinery" is true
+  in the strong sense: the hero reuses the runner's work product,
+  not just its code.
+- A machine collect never crosses a fed input boundary. Dispute
+  levels tile inside one level-0 stride (inside one window); the
+  runner's schedule is per-window by construction; the only
+  cross-window collects are inputless-epoch level-0 spans, which
+  are idle arithmetic with no feeds. Boundary crossing belongs to
+  positioning (advance) and idle replay only - which should let the
+  collect side of coarse_step_until shed its mid-collect feeding
+  support in step 4.
+
+Outside the shared machinery, deliberately: the epoch lifecycle
+(roll, settlement derivation, outputs proof, accepted/rejected
+recording) is the runner's own, and the react/tournament layer is
+the hero's own. Neither is geometry.
+
 Risks and their nets: this is a consensus-critical migration, and it
 has the strongest verification net in the codebase - the spec oracle
 (conventions), the prototype differential (real machine), the Lua