The Open Frontier

Program History. This is the 2D / single-spin-era experiment log: measured, falsified, and kept as provenance. The current measurement record lives in the Friction Substrate monograph; the current engine is moore26 (Cartan's Cascade); Joule's Mill is the archived meso3i instrument

The following is the immediate roadmap for the framework: how the current 2D mechanics scale toward volumetric observables. None of this is implemented in the engine yet; it is the theoretical trajectory, kept honest by that distinction.

The engine is already a flat 1D array: calloc(PIXEL_COUNT, sizeof(PlanckNode)). The "plane" exists only because the routing table wires node to specific neighbors via modulo arithmetic (y·W + x). There is no geometric container. It follows that "3D space" is not a stack of 2D sheets: it is simply a wider coordination number. Going from Oct8 (8 exits) or Hex6 (6 exits) to a 3D substrate means giving each node 12 (hexagonal close-packed), 14 (body-centered cubic), or 26 (3D Moore) valid neighbors in the same flat array. The field isn't deeper; it has more exit vectors per locus, more ways to dissipate thermodynamic friction.

• Gravity as congestion overflow: on a wider graph, a saturated node's in-flight buffer can route overflow through the extra adjacency channels instead of stalling. 3D gravity is routing overflow across the expanded matrix, not an interlayer phenomenon.
• Cross-sections () → waveguide shearing: how many adjacency channels of a phase-locked knot must fail before the structure loses hydrodynamic integrity. (The 2D engine already measures this natively: quantized severing counts in the bombardment scenarios.)
• Resonance widths () → synchronization endurance: the number of ticks a knot sustains phase alignment against ambient thermal jitter before unwinding into actualization yield.
• Quantum spin: not an abstract intrinsic property but the routing-phase offset required to weave a self-sustaining standing wave through the expanded graph.

Measured: The Adjacency-Expansion Experiments

The following results were measured in src/engine-sim.mjs by widening each node's routing table with one extra adjacency channel (a counterpart at depth±1), carrying buffer overflow and deadlocked sends as pressure-driven, spinless flux. These are instrumented outcomes, not proposals, including a falsified hypothesis.

• The Skin Effect: at hexjam flux density, a single extra plane absorbs the entire 1.7M-quanta overflow. A 2D plane is an almost inexhaustible entropy sink. Mass penetrates exactly one slab deep. This is a measurement of why the universe defaults to flat quantum foam: rendering bulk 3D structure requires a thermodynamic event violent enough to saturate multiple planar capacities simultaneously.
• The Squeeze: depth propagation beyond the first slab occurs only when the adjacent layer is itself congested (a seeded mid-jam forced mass through to a third slab, with a thin trickle reaching a fourth. Each plane is another skin-depth barrier). When every reachable plane is jammed, the surface deadlock rebuilds to its un-expanded count: the relief valve works only while a non-jammed plane exists downstream.
• Quantized accretion pulses: vertical mass transfer is not continuous. Long static plateaus punctuated by discrete threshold-break events that dump a packet and re-lock. Accretion happens in packets, matching the framework's quantized exchange premise.
• The Dissipative Verdict (falsified): we hunted a Z-axis standing wave, a volumetric resonant cavity, and it does not exist in this mechanism. Vertical overflow is dissipative escape, not elastic coupling: escaped flux diffuses across 160,000 nodes of planar capacity rather than building recoil. The cavity rings once, then equilibrates. Collider-scale resonance cannot emerge from congestion alone; it requires an elastic restoring force (e.g., a vertical structural phase-lock that binds node pairs across depth). This constraint is now recorded so the resonance hypothesis cannot be re-proposed without addressing it.
• Pipeline vs. Attenuator (falsified): we measured tunneling by letting saturated ports leak a fixed ~1.6% of blocked flux (+seep, closed-ring seepwall scenario). Transmission is real, ~187k quanta crossed a supposedly hard wall, but thickness-independent: peak transmission was flat from t=1 to t=3. A mass-conserving buffer warehouses leaked flux and relays it at the same rate per hop; the wall is a pipeline, not a probability barrier. Exponential decay () would require per-stage absorption, each barrier node thermalizing a fraction instead of forwarding it. Bonus emergent finding: deadlock walls thermally erode even with zero seepage. Refused arrivals still charge propagation heat, so no barrier in this universe is permanent.

Re-audited under v3.0

After the engine went fully discrete, integer momentum, argmax spin resolution, LUT quadrature budget, and unwinding began conserving mass as radiation spray, we re-ran the falsified experiments to check the verdicts hadn't been artifacts of the old approximations. The harness caught one real suppression (the old code deleted unwound mass. See Audit 5), so the re-measure was warranted:

• Dissipative verdict. Confirmed. Under conservation, the seeded squeeze still produces strictly positive, decaying zFlw pulses: no sign reversals, no anti-correlated slab exchange. One refinement: mass penetrates measurably deeper (a persistent ~3.7k reaches the third slab where the transient used to flash and die), unwound radiation keeps feeding the squeeze, but it remains escape, not oscillation. The elastic-restoring-force constraint stands.
• Tunneling: confirmed, mechanism sharpened. A weak retention gradient exists early (+~12%/layer at t=100) but washes out by t=200. Buffer decoherence now taxes in-transit staged flux, and spray deposits dissolved wall mass outside the barrier: the exterior count conflates transmission with erosion. Asymptotic attenuation still does not emerge.
• New phenomenon: thermal self-regulation. Under v3.0, structures park hot cells just under the thermal limit and vent via unwinding spray. A thermostat made of microscopic detonations. The float-era hexcycle fixed point was an artifact of permanent deadlocks absorbing the mismatch as heat sinks; the discrete dynamics run hotter and regulate themselves. What reads as "leaking" in the entropy layer is this radiation simmer, honest physics, not a bug.

Causal Mechanics Probes (Stage 1–2)

Two instruments were added to engine-sim.mjs to test causal-mechanics claims against the shipped engine: neither required new physics in planck.c to produce a measurement.

• Distance is propagation latency, confirmed, with structure (+latprobe, overdensity pulse vs. pulse-free control): on a free corridor (hexstream) a density wave transits 281 cells in 134 ticks ≈ 0.48 ticks/cell, the wave outruns bulk transport (a sound-like mode). Through hexjam's upstream pressure pile the wave crosses 152 cells in 63 ticks ≈ 0.41 ticks/cell: a congested field is stiffer, not slower, for the signal. But below the throat the tagged mass never arrived in 340 ticks. Even at 120-cell gap width. Signal latency is congestion-insensitive; bulk latency is set by port throughput and can become effectively unbounded. Distance-as-latency is real; the wall is a selective membrane, not a speed bump. (Open tension: ~0.48 ticks/cell means the density wavefront propagated at ≈2 cells/tick. Faster than the c=1 hop/tick bulk transport limit. The wave is a sound-like mode riding pre-staged occupancy, not packet motion, but the reconciliation of wave speed vs. flux speed remains an open audit item.)
• Halving wave on head-on conflict, real but outgunned (+halve, conflict-scoped ½-opposing + ¼+¼-lateral momentum split on cs === d arrivals): inert on hexcycle (300/300 through t2000. The scope correctly never fires on healthy circulation), hexcycleb, and hexjam. On the new hexcollide variant (two 180° streams meeting head-on) the mechanism is measurable: early spray −12%, surviving knots +38%, mass spread into more sectors (balance 0.15 vs 0.11). But the front still detonates at 65535 by t50. The acoustic channel exists and redistributes laterally as predicted; at this energy density it cannot prevent the blowoff. Flag-gated pending a decision on split fractions or lower-energy scoping.
• Stateless pressure asymmetry, falsified as gravity (+press, per-tick neighbor occupancy → momentum bias): nearest-neighbor pressure is a contact force, not a field. It cannot act beyond one cell, so hexlens at impact parameter 50 feels nothing, and on hexcycle it pulls the ring's own halo inward until circulation collapses (300/300 → ~40/300 by t200). Occupancy-summation "gravity" produces local collapse, not curvature, a useful negative result: gravity needs a propagating carrier.
• Propagating tension field, stable and benign, but streams accrete rather than lens (+tension, hexlens variant): deadlock-gated occupancy emits a u8 scalar that diffuses at channel-share rate and decoheres per-tick, a real graded well with finite range (ℓ ≈ √(D/λ) ≈ 10–25 cells at tuned values). The field passes its hard regression: hexcycle survives 300/300 to t1000 (the q=90 ring sits below T_EMIT_MIN=200, so bound circulation neither emits nor is disturbed). But on hexlens every steering coupling shows the same binary cliff. Spin-pull (argmax) either can't reach the 60°-quantized turn threshold or spirals the stream into the knot; duty-cycling only slows capture; flux-shear (arrival deflection into the up-gradient buffer) is invisible at ≤1/32 and accretes at ≥1/16. Streams are sticky mass flows, not rays: a well strong enough to bend one is strong enough to eat it. Two honest paths remain: measure the capture cross-section vs. impact parameter as the substrate's actual "gravity," or replace diffusion with ballistic tension transport for true long-range reach (B=50 is outside diffusive range on experiment timescales).
• Accretion cross-section measured, the substrate's native gravity (hexlens, LENS_B sweep at T_DIVERT=4, shear-only coupling): the capture curve is structured, not monotonic. Direct hits are erosive: a stream at B=15 strips the knot below its own baseline (capD 98→50, a tidal-stripping analog); the balance point sits near B=20; grazing incidence captures. At B=25–30 the sheared boundary-layer mass binds into new deadlocked cells around the well (+65 to +95 knots, an accretion-disk analog) while the stream sheds ~55% of its quanta; and the interaction cuts off at B≈35, exactly the diffusive reach ℓ. The threshold is sharp in coupling strength: >>4 shear accretes, >>5 is transparent at every B. Gravity in this substrate is not trajectory curvature: it is local accretion, stripping, and capture via a propagating tension gradient, strongest at the well's edge rather than its depths.
• Suite sweep + oct8 parity, shear-only coupling settled: running +tension across the full scenario suite shows one consistent signature, the field is anti-compressive. hexcycle is inert (ring below T_EMIT_MIN); hexsnow accretion is suppressed ~4.5× (351→76 knots. Sheared infall misses the sink); hexjam's own wall emits a field that disperses the upstream pile (4140→2053 deadlocked); hexbraid junction knots drop ~45%. The oct8 port produces the identical signature (electron: 1390→89 knots) with a graded radial profile. The mechanism is substrate-independent. Spin-pull coupling was rejected: duty-cycled torque on top of shear collapsed hexsnow further (21 knots) while adding no structure. Shear-only keeps the port to three parameters and no timing machinery. Because the field legitimately rewrites barrier/accretion scenarios, any planck.c integration belongs behind an off-by-default flag.
• Congestion gravity is load-bearing, the two mechanisms compose, not compete (+nograv under the tension baseline): removing the cong steering from hexjam is catastrophic. The stream detonates on the wall face (spray peaks at 4M quanta, the wall unwinds and stops emitting). Congestion gravity is the near-field routing layer (steer flux off saturated ports); the tension field is the far-field propagating layer (gather, strip, bind at range). Same congestion physics, two scales: both stay.
• Tension is now the canonical baseline: the harness defaults to +tension on (+notension A/Bs it off) with the measured parameter set (EMIT_MIN=200, EMIT=4, SHARE=3, DECAY=5, DIVERT=4, shear-only). hexjam retuned to JAM_GAP=30. The jam reforms and upstream congestion visibly emits its own field. New probe variants: hexaccretion (B=28 grazing stream. Bound mass grows around the well, +58 deadlocked cells by t400) and hextidal (B=14 compact projectile: the well absorbs ~2× its baseline mass at impact, spray plumes, then decays toward equilibrium). hexcycle stays 300/300 at t600; electron on oct8 settles into a breathing ~90-knot torus instead of a frozen 1390-cell brick.
• Active ZPE vacuum, implemented, validated as a field, falsified as a shield (RFC-042: hexzpe/hexcyclez, bipartite E/W reciprocating q=1 floor): the carrier lattice works exactly as specified. hexzpe holds netP = (0.0, 0.0) at every tick (macro-isotropy), mass-conserves, deadlocks nothing, and self-maintains the alternation through Phase Lock alone (the seeded parity spins only matter at t=0 and behind wakes). It settles to a warm equilibrium h≈181. The friction floor of the 180°-reversal exchange. But under the ring test the hypothesis is rejected: hexcyclez severs earlier than the stochastic-foam control (282/300 at t100, 213 at t150, vs foam's 300 and 257. Acceptance criterion 1 fails) and its dissipation is ~5× foam's (totH 22.6M vs 4.2M. Criterion 2 fails). The mechanism is visible: the ring eats the floor. cycleQ balloons 27k→38k as ambient flux fuses with the loop, deadlocks climb 217→350, and the t300 dump shows a cleared wake where the ring consumed the vacuum before destabilizing (netP drifts to −5552). A continuous q=1 floor delivers more total bombardment than 5% sparse foam, and in this substrate ambient mass is food for the structure, not lubricant. There is no "cold-start reorientation penalty" for it to dodge (silence already holds spin; dead cells cost nothing to enter). The clean-wake reset rule was A/B'd (ZPE_NOWAKE): differences are within run noise. The failure is the floor mass, not the reset. Two salvages: late-run the coherent floor erodes slower than sparse heavy foam (144/300 vs 94/300 at t400, structure prefers continuous weak flux to random heavy hits), and the pure-vacuum benchmark stands as a validated zero-net-momentum ground state for future probes.
• Distributed vortex envelope. Thickness is neutral, streamline closure is everything (RFC-043: hexvort{1,4,8,16} naive tangent paint, hexvort{N}x exact same-ring trace, f=1% light foam, F=5% heavy foam): the RFC's literal Gaussian-annulus paint fails at every width. Sextant-quantized tangent headings are open streamlines, so mass leaks radially, crosses adjacent streams, and nucleates deadlocked knots whose tension fields then amplify the clumping (tenMax→164; sectors collapse into 2–3 dense orbiting beads, a "vortex necklace" instability, monotone worse with width: ccirc@t300 = 0.07/0.03/0.02 for W=4/8/16). Re-painting with closed streamlines changes everything: exact-trace envelopes are perfectly lossless in vacuum, ccirc=1.00, bandQ constant to the quantum, fdead=0.000 for all W through t400. And under 1% foam the thick envelope does deliver the predicted resilience (hexvort16xf: ccirc=1.00 through t400 while the thin ring erodes to 0.93; the envelope gently accretes ~+750 foam quanta without disruption). But under hexcyclep-grade 5% foam the ordering inverts: hexvort16xF collapses to ccirc=0.03 by t300 (larger cross-section, ~85% of stored mass cascades into knots) while the thin traced ring degrades gracefully to 0.23. H1 survives only in a bounded form. Redundancy pays below the bombardment threshold where hits are absorbed, and mass becomes liability above it. The refined principle: particles on this substrate need closed orbits, and the durable thin ring with its dead moat (hexcycle) remains the strongest long-term configuration under heavy load.
• Flank shield. A real mechanism that fails its own purpose (RFC-044: +flank, sender-side intake refusal scaled by heading-vs-target-stream angle dd, refused quanta retained as lateral pressure): the shield bites exactly as designed, misaligned merges are refused and mass backs up at the refusal front, but it cannot produce lamination. hexsnow under flank gains deadlocks (207 vs 90 control: refused infall piles upstream and saturates anyway, a wall, not an onion). hexvort16 still necklaces (ccirc 0.03–0.29, orbitCv 3.7 vs 0.5 painted. Worse than the naive control's own variance). And at the schedule strong enough to matter, it breaks hexcycle (300/300→90/300 by t100: ring corners are dd=1 merges, half-refused flux backs up past the q=90 deadlock margin, and the incompressible jam cascades around the loop). The structural finding: dd=1 is simultaneously the corner-merge angle of every closed orbit and the lateral-infiltration channel. A local angle filter cannot tell them apart on a 6-port lattice. Gentle schedule (SH1=0) spares the ring but leaves the leak open and the envelope still beads. Two confirmations worth keeping: the shield is provably inert on closed streamlines (hexvort16x under flank: ccirc=1.00, fdead=0.000, it only bites misaligned flux), and it is a genuine regime gate, q=64 corners equilibrate at ~2q < DEADLOCK while q=90 does not, so refusal converts misalignment into bounded accumulation only below the deadlock margin. Flag-gated, not canonical.
• Z-venting diagnostic. Knots are the symptom, streamline crossing is the disease (RFC-045: hexvort16 under +zshadow/+zshunt): the out-of-plane relief channel was probed as a cure for necklace nucleation, and the two channels split the answer decisively. +zshadow (receiver-side, fires on buffer overflow b>255) is identical to control: deadlocked 213 vs 211, fdead 0.237 vs 0.238. Because the vent addresses the buffer register while necklace knots are occupancy deadlocks (stalled q+b>200 mass that sits). +zshunt (sender-side, fires on refused deadlock ports) does prevent the knots: fdead 0.031 vs 0.238, ~8× fewer saturated cells. But at the cost of bleeding 79k quanta (~43%) off-plane, and the envelope still decoheres completely (ccirc 0.08, orbitCv 3.4). The necklace is not a pressure-accumulation problem that venting can solve: it's an open-streamline-crossing problem, and deadlocks are merely what stalled crossings look like. Removing the deadlock symptom just relocates the failure: mass exits the plane instead of clumping in place. A true 3D circulatory lattice might laminate, but only because it would offer real routing options (new closed orbits), not because it offers a drain.
• Spin-preserving Z-overpass. Vectors survive, windings don't (RFC-046: +zhopfion, deadlock-diverted quanta enter slab 1 carrying their spin and attempt re-entry two hops downstream each tick): the mechanism works exactly as designed, knots suppressed to the lowest level of any configuration tested (fdead 0.015, deadlocked 17 vs control's 193). And it still fails both acceptance criteria. orbitCv hits 4.65 (the worst variance measured: displaced re-entry smears mass across rings instead of laminating it), and the band bleeds 183k→30k with ~40k quanta queueing on the overpass (downstream ports refuse too. The jam doesn't clear past the hop). The conclusion sharpens RFC-045's: a Hopfion's poloidal return is a curved path that re-enters at the same axial position in the winding. Preserving the spin vector while displacing the packet destroys the very topology it was meant to keep. Topology lives in the shape of the 3D path, not in a direction label attached to the mass. Three RFCs now converge on one law for this substrate: structure survives only on paths that are closed by construction. Paint, mechanics, and shortcuts all fail to conjure one afterward.
• FCC substrate & the painted Hopfion, 3D relieves knots, not quantization (Phase-3 prototype: 12-neighbor stacked-hex lattice, 100×100×40, z hard-surface, ports 1-6 equatorial / 7-9 zenith / 10-12 nadir with parity-interleaved triples): the substrate itself is proven, hopfring (exact-trace ring in the mid-layer) holds bit-identical through t400, and the degree-normalized diffusion exports a correct 75%/67% at deg 12. But hopfion (torus R0=25, tube R1=9, painted toroidal+poloidal field) collapses anyway: −83% mass thermalized by t400, tube occupancy −95%, coherence ~0.25. The component split is the discovery: pure toroidal necklaces (fdead 0.31. The equatorial layer IS the hex lattice), while pure poloidal shows fdead ≈ 0.04 with full dispersal, the third dimension genuinely prevents knot saturation (the RFC-045 signature of true 3D freedom), but mass diffuses instead of clumping. Verdict: the law survives another substrate. Quantized continuum paint is not a closed discrete orbit, in any dimension. A real Hopfion on this lattice would need its field lines exact-traced over the torus, the way hexcycle's ring is traced over its hexagon, not painted by formula.
• Exact-trace Hopfion, closure exists, lock-tolerance kills it (RFC-047: hopfionx pathfinder paint, greedy field-following over NT3, loops kept only on exact seed return): unconstrained tracing closes only 2/29 seeds, and those loops fail anyway. hold→0 by t50 while mass conserves (re-wiring, not thermalization). Root-caused to the parity interleave: vertical ports' planar azimuths alternate {1,3,5}/{2,4,6} by layer, so a descending turn at any fixed azimuth exists only on alternating layers. Every non-planar winding is forced through >60° hops that Phase Lock re-locks to straight-ahead. Adding lock-tolerance as a trace constraint yields 0/29 closures, and the failure modes split cleanly: in-plane (pure toroidal), the ring's 60° hops pass the constraint yet greedy field-following still never returns to seed, because following a continuous tangent doesn't recover a discrete cycle (hexcycle's paint enumerates ring cells by hexDist and advances by angle. Closure must be sought as a graph cycle, not traced along a field); and for vertical windings, single-seed debugging shows the needed descent port literally absent. On even layers no nadir port exists at azimuth dir4, so a flow descending inward must turn >60° and gets rewired. Verdict: closed 3D windings on the parity-stacked lattice contain unavoidable sub-threshold turns. The angular-bandwidth wall of RFC-044 reasserts itself in 3D. An FCC substrate whose 12 neighbors are not parity-split (full cubic coordinates, or ABC-stacked trilayer with a third offset set) may evade the frustration; the stacked-hex shortcut cannot host a Hopfion as a single-valued spin cycle, and field-line tracing is the wrong search even where cycles provably exist.
• Degree-normalized diffusion, latent oct8 misalignment corrected (post-RFC-045 ratio audit): several engine ratios were degree-coupled bit-shifts that silently scale with neighbor count rather than describing physics. Worst case: TENSION_SHARE. Hex6 exported 6·(tn>>3) ≈ 75% of the field per tick while oct8 exported 8·(tn>>3) ≈ 100% (a full swap, different diffusion physics), and a hypothetical 12-neighbor lattice would overshare the register negative. Heat diffusion had the same shape (hex 2/3, oct 8/9 export). Fixed in both engines with normalized per-channel shares, 3v/(4·deg) tension, 2v/(3·deg) heat, which reduce bit-identically to the legacy shifts at deg=6 (hexcycle trace unchanged) while pulling oct8 back to the same 75%/67% export fractions (octmix re-verified: 197 knots, breathing; electron relaxes slower under cooler diffusion, 350→112, without runaway). Remaining known misalignments logged for the eventual 3D substrate: the DEADLOCK=200 < BUF=255 threshold stack means buffer-overflow relief always arrives after occupancy already froze (RFC-045's register mismatch), NODE_BANDWIDTH_MAX=220 assumes ~6-channel routing load, and the z-channels deliver arrivals spinless. A phase-dropping sink can vent mass but can never host a Hopfion's topological winding.
• Latent bug exposed and fixed, BWF_LUT u8 wraparound: the vacuum floor was the first configuration that made a real defect visible. BWF_LUT[r] = round(256·√(1−(r/220)²)) evaluates to 256 for r ≤ 13: which wraps to 0 in the uint8_t/Uint8Array table, silently zeroing heat dissipation for any cell with routing load ≤ 13. Invisible under dead vacuum (nothing generated heat to dissipate); under the q=1 floor every cell generated ~24 heat/tick against zero drain: a linear heat ratchet that pinpointed the defect. Fixed to uint16_t/Uint16Array in both planck.c and the harness. This is a canonical physics change: low-routing cells now dissipate as designed (hexcycle/hexjam/octmix re-verified clean under the fix).
• Chunk+halo memory architecture for the 3D engine: RFC-049 PASSES with a measured tradeoff (src/planck3.c, verified native -O2 AND in wasm, planck3.wasm halo mode reproduced the JS t400 state with 0 mass-channel diffs via state dumps test/loom/t0.bin/t400.bin): the FCC substrate was ported to C with three selectable memory models. Flat Node3[N3] with arithmetic neighbors (control), the RFC's 20³-interior/22³-block chunk+ghost-ring architecture (halo exchange each tick, pushes resolve the owner chunk arithmetically. No cross-chunk pointers stored), and an ordered-chunk variant (chunked storage, flat global sweep order, no ghosts). Results at 100×100×40 on the RFC-048 Hopfion state: C flat vs JS harness, 0 mass-channel diffs over 400 ticks (q/s/b/tn byte-identical on all 400k cells; heat differs only by floor-RNG streams, which never feed back into mass). Criterion 2: bit-identical port achieved. Criterion 3: halo chunks run 1.15–1.7× faster than flat (24–28s vs 29–47s per 400 ticks native -O2. Locality plus cheaper add-only neighbor indexing vs flat's 24 modulos/cell). The honest wrinkle: under knot conditions (injected 8³ saturated blob, where tension-divert/spray pushes actually fire), halo mode diverges, 125k cells differ at t400, because pushes are ordered by global (z,y,x) position in flat but by chunk-order in the halo sweep; the speed is the reordering. The ordered-chunk mode stays bit-exact everywhere (0 diffs under knots) but costs 0.6× flat. Per-neighbor owner resolution eats the block-scan win. Verdict: all three engines share one planck3_node_tick; halo is the production path for the laminar regime the engine exists for (stable structures emit zero pushes. Measured spray=0/divert=0 across the acceptance run), flat/ordered remain the exact references for congested transients. Chunked storage also deletes the 20MB NT3 neighbor table. The wasm build (planck3.js, createPlanck3) is wired in src/build.sh; DFS paint remains harness-side: the C engine consumes traced states via planck3_set_node/bulk load.
• WebGL2 volume renderer, RFC-050 ("Hopf's Loom", docs/.vitepress/loom/main.js + LoomSimulator.vue + /loom-demo): the engine's {quanta,spin} registers are packed in-place into an RG8 buffer on the Wasm heap (planck3_rg_refresh) and uploaded per frame via gl.texSubImage3D. Zero JS array copies, per the directive. One drawArraysInstanced(TRIANGLES, 6, N3) call renders 400k billboard quads (instanced quads rather than gl.POINTS: several mobile GPUs cap point size at 1px). Vertex shader does texelFetch per gl_InstanceID, culls vacuum, ghosts nodes outside the tomographic slab (elevation + thickness uniforms, ~6% alpha silhouette rather than a hard clip), and applies the honest embedding: the substrate is stacked-hex with parity-free ports (the ABC stagger lives in the port offsets, not layer origins), so nodes sit at x + 0.5·(y&1), y·√3/2, z·√(2/3)≈0.816; a literal z%3 layer shift would misstate the connectivity. Spin classes color the knot, equatorial (toroidal) warm, zenith cyan, nadir violet. Deviation from §1: bulk state loads via planck3_load_pointer/planck3_load_commit (P3ST blob → wasm memory in one HEAPU8.set + C-side unpack) rather than 400k set_node calls. Physics budget is adaptive. A tick costs ~80ms in wasm, so the viewer self-throttles rather than stall the UI; HUD reports real ms/tick. UI ergonomics: 44px touch targets, quick-view presets (Full / Equator Cut / Core Bore / Lattice Plane), auto-turntable with 4s idle resume, Gaussian billboard falloff, and flat engine mode locked as the canonical path (halo/ordered retained in planck3.c for future worker profiling, disconnected from the frontend).
• True FCC (ABC) substrate + a stable multi-loop 3D Hopfion, RFC-048 PASSES (hopfionx on the parity-free lattice; printSlice tomographic viewer): the A-B-A-B parity interleave is replaced by a parity-free 12-port geometry. Every layer offers zenith ports {1,3,5} and nadir ports {2,4,6}, so a single port index hops the identical offset layer-to-layer and traces a straight 3D diagonal through the A→B→C→A cycle (the RFC's z%3 azimuth cycling is the same invariant stated layer-relatively; the fixed-triple form makes reciprocity immediate: 4,740,000 edges, 0 broken). The descent port that HCP deleted on alternating layers now exists everywhere. On the new graph the memoized-DFS pathfinder closes 19/29 seeds (27,971 cells, ~1.68M quanta) under the strict Phase-Lock constraint, each hop within 60° of the incoming dom port, not merely the travel vector, with steepTurns=0. First batch still decayed (−83% mass, hold→0); root-caused by a t=5 probe plus an in-degree audit: a seed landing on an already-painted cell overwrote its spin. The old predecessor kept feeding it (double inflow → buffer overflow → first deadlock inside 5 ticks) while its old successor starved (inflow=0 → s→0 → dead link cascade). Vetting seeds against hopfMask yields a perfect in-degree-1 graph (inflow[0,1,>1]=0,27971,0) and the assembly is then bit-identical through t400: totQ 1,678,260 constant, tubeQ constant, paintQ constant, deadlocked=0, spray=0, hold=1.00. Single-loop controls (478- and 1999-cell non-planar cycles) were already bit-perfect, so the fix converts "stable isolated loop" into "stable nested-loop Hopfion envelope." Residual honesty notes: coh=0.61 counts cells whose quantized port lies within 60° of the continuum ideal field. A quantization ceiling, not an instability (the structure itself never deviates from its traced spins); closure is found for ~2/3 of seeds, so the painted envelope is a subset of the ideal field lines, not a complete torus foliation. The law stands and now has its positive form: closed streamlines by construction are not merely necessary. On a substrate that admits them, they are sufficient for a stable 3D particle.

The Kinematics Campaign (Stage 3): Can Matter Move?

The following was measured on planck3.wasm via the headless harness suite (script/sweep.mjs → boost.mjs → collide.mjs → quench.mjs) over the True-FCC lattice. The program set out to map a topological S-Matrix; what it found instead is a measured property of the substrate: bound structures do not translate.

• The particle dictionary: 37/37 stable specimens. pathfinder.mjs exact-traces closed port cycles under the Phase-Lock ≤60° constraint; sweep.mjs ticks each seed 400 ticks in planck3.wasm and records invariant mass, RMS cross-section, spray/deadlock telemetry, and per-window series. Every measured specimen holds its traced spins bit-perfectly. The substrate sustains matter exactly as RFC-048's law predicts: closed streamlines by construction are sufficient.

• Boundary-flux boost: survives everything, moves nothing. boost.mjs drives quanta/tension/spin/heat envelopes through 24 axis+polarity boundary vectors into a resident knot. At every survival-safe flux the skeleton centroid does not displace: not a fraction of a cell. The knot neither rides the beam nor is pushed by its tension gradient; at destructive fluxes it erodes in place. First datum for lattice-locking.

• The pinch "S-Matrix": no ballistic channel exists. collide.mjs dual-spawns two dictionary knots ±separation on an FCC axis and applies a symmetric ADSR tension pinch (peak 20) at both walls. For ~825 ticks of a 1000-tick run the gap is frozen to two decimals. The pinch never propels the knots together. The t=999 outcomes are not scattering events: head-on identical twins undergo an asymmetric erosion race at ~92 cells of residual separation (retain 0.01% vs 4.2%. Resolved by symmetric_swapped: reversing the axis flips which mask retains, so the ~4% floor is a positional update-order artifact of the row-major serial scan, not a property of either knot), while glancing b=15 "fusion" is halo bridging, accreted ambient mass containing B's painted markers, not physical knot contact (gap never closes below ~128). Reinterpreting the b-sweep: it maps halo-bridging reach vs lateral offset, not a scattering cross-section.

• Galilean spin boost. Falsified as momentum. A uniform drift vector blended into each cell's circulation spin (requantized to the nearest FCC port) should advect the knot if spin is a momentum carrier. It does not: the boost is a wound, not a velocity. At mag≥0.5 the requantization breaks the phase-locked circulation: live mass collapses ~80% within 25 ticks, the remnant live-centroid wanders ±15 cells, and no component ever propagates ballistically. With painted provenance static at spawn, translation was tracked by a new live-component centroid channel. Which never moves. Second datum: injecting "momentum" as spin direction shreds the structure instead of propelling it.

• Lattice-locking: the synthesis. Three independent momentum mechanisms, external tension pinch, directional wall flux, and internal spin-field drift, all fail to translate a bound structure. Matter on this substrate does not advect; it erodes, sprays, and reconstitutes elsewhere (the ±13-cell remnant wander is migration-by-reformation, not motion). The implication for the ontology: inertia is routing friction. A defect's phase-locked circulation is load-bearing topology, and "moving" it means destroying and rebuilding it. There is no ballistic channel, so particle interactions are proximity/contact-mediated, not collision-mediated. The S-Matrix program as classically posed is answered: the elastic threshold is absent because the projectile is absent. If anything here deserves the name "motion," it is propagation-by-reconstitution: which makes chiral nucleation (can the lattice grow a closed knot from an open arc?) the operative dynamics question rather than scattering.

• Capacity-stealing probed directly. The quadrature budget shows its choke. quench.mjs (Audits §3) paints a controlled heat deposit on a beam-loaded channel vs an off-beam control. Two instrumentation facts reshaped the probe: cooling is quadratic ((1+ts²)·diss·BWF[routing], ts=h/200. A 20k deposit evaporates in one tick), and sustained beams deplete in transit (~15-cell half-life), so load is maintained by a source-zone channel. The honest observable is equilibrium heat, not deposit decay (the quadratic drain drowns a 300-unit deposit when baseline ≫ deposit): loaded channels hold h≈1,400–1,600 steady-state vs ≈2 ambient, routing load measurably prevents cells from shedding heat. (Sync-corrected figure: under the mass-conserving g_sync update, deferred pushes persist rather than evaporating at publish, the same loaded equilibrium settles at h≈410–450; the ~3.4× drop is the phantom-mass leak priced in, not a change in mechanism. The load-vs-ambient contrast, ~200×, survives either engine.) The negative control is the sharpest signature: buffer-loaded cells (energy-dense but unrouted by design) emerged into a self-choked state, parked quanta emit tension → congestion → routing saturates → BWF→~0 → cooling off, stabilizing at h≈37,000 where generation finally meets the residual drain. Capacity-stealing exists in the engine not as an imposed rule but as an emergent fixed point.

• Engineering audit: the stale-state-pointer bug. planck3_state_pointer() returned g_rd, which ping-ponged between two buffers each tick; every harness that cached it injected into the retired buffer on alternate ticks (~half-strength drives) and read a one-tick-stale frame half the time. Bit boost.mjs, collide.mjs (pinch ran ~half envelope strength across the collision matrix. The frozen-gap conclusions stand, since centroids were static on both buffer parities), and quench.mjs; the browser path was immune (it never sees the raw pointer). Fixed engine-side: flat tick now publishes via memcpy-back into a fixed g_rd. The pointer is permanently stable, dynamics verified bit-identical (0 mass-channel diffs flat/chunk/ordered + JS reference, totQ=1,678,260 across all modes), ~1–2% memcpy overhead. Recorded so no future harness re-learns it.

The Nucleation Campaign: Can Matter Grow?

With motion falsified, the remaining dynamics question is growth: can the lattice close an open chiral arc, and can raw flux condense into a loop at all? Two instruments, script/anneal.mjs (scaffold repair) and script/fountain.mjs (sustained chiral injection), same census: live cells, free ends (live spin → dead target), longest live spin-cycle, nontrivial-cycle count.

• Arc repair. Topology healing is real, threshold ~0.55–0.6, geometry-dependent. Cutting a contiguous arc from hopfion_25_9's longest cycle (2001 cells) and releasing it: ≥0.60 re-closes. The free tail erodes ~1 cell/tick until the surviving fragment spontaneously phase-locks into a ~1,000–1,140-cell closed cycle (freeEnds→0, durable through t300). 0.55 is the phase boundary: a 100-cell cycle transiently forms at t≈97 then ruptures (remnant mass exceeds the small orbit's carrying capacity. A hydrodynamic blowout), and the fragment shatters into dozens of open strands. ≤0.50 dissolves. The control (hopfion_30_9's longest loop) fails at 0.6 and 0.8, fragmentation cascade, 721 free ends, so repair is parent-geometry-dependent: the ~1,000-cell convergence is not a universal lattice attractor, and the closure threshold is a property of the specific winding, not a constant.

• Sustained feed does not substitute for scaffold. Pinning a sub-threshold arc's tail to 80q/tick (fountain.mjs --mode=tail, arc=0.5) reproduces the blowout signature exactly: transient 185-cell cycle at t≈350, rupture, then freeEnds→353. Raw flux poured into an open end cannot buy what missing topology would have provided.

• The chiral fountain: strong nucleation falsified under every confinement regime tested. A ring of 24 aperture cells at mid-plane, each forced to a tangential+0.6·up spin and 80q/tick (--mode=ring. Nothing chiral is ever painted except the aperture spins): in vacuum the stream sprays laterally (~830 live steady-state, ~95% free ends, maxCycle=2 forever. Zero self-organization, the predicted impedance-free limit). An ambient --foam=5 noise floor decays in ~25 ticks and never confines (38.5k/39k free ends). Convergent wall quanta (--pinch=5..20) cannot form a steady vessel: injected mass has no drain, so every strength floods toward saturation into the same micro-cycle soup (maxCycle≤5, nCycles~40, dimers and trimers, never a soliton). The corrected vessel, a tension-register wall shell (--ptension=60, pressure gradient with zero mass injection), confines nothing: ~1,839 live, ~95% free ends, maxCycle=2. Verdict: raw chiral flux does not self-curl into phase-locked cycles under vacuum, noise bath, mass confinement, or pressure confinement. The lattice sustains exact topology and repairs near-complete topology; it does not invent topology. Nucleation in the strong sense is bounded below by a ~60%-complete compatible scaffold in every regime instrumented so far.

• Artifact sweep. The retention "constant" was update-order grain. symmetric_swapped (bsweep finale): retainA=0.0423, retainB=0.0001, the mirror image of the unswapped head-on. Survival follows position along the spawn axis, not knot identity: the row-major serial update deterministically disadvantages one end. Every collision asymmetry measured to date traces to scan order, not to the knots: the S-Matrix campaign stayed benched pending a synchronous-update mode.

• Synchronous update built. And the residual asymmetry is deeper than scan order. planck3.c now supports g_sync (planck3_set_sync): the two mid-tick push sites (tension-shear divert, thermal-unwind spray) defer into a queue that flushes into g_wr before publish. Uniform g_rd reads all tick, and diverted mass persists (legacy semantics silently vented it at the publish memcpy; symmetric_swapped --sync shows ~101k live cells at t999 vs ~37k legacy). Legacy mode remains the bit-identical default (0 mass-channel diffs, all modes + JS reference). Under sync, symmetric_swapped returns retainA=0.2594 / retainB=0.0039. The positional bias survives synchronous update, and the likely source is the substrate itself: the ABC-FCC port set is chiral. X-mirror maps zenith planar dirs {1,3,5} onto nadir-only dirs {2,4,6}, so no +z port exists with a −x planar component. Mirrored x-positions are inequivalent environments; the only true mirror plane is ⊥y. The y-mirror discriminator confirms it: under sync, ymirror_axis1 (+x+y separation) returned retainA=0.3109 / retainB=0.316 and ymirror_axis5 (+x−y, its exact y-reflection) returned retainA=0.3146 / retainB=0.3193. The mirrored pair reproduces each other within ~1%, and within each run A≈B. Along a direction the lattice actually mirrors, the engine is parity-clean; along the chiral x/z grain it is not. The scan-order artifact is dead (the 0.0423 "constant" vanished with the deferred-push queue), and what remains is a genuine structural property: the substrate violates parity along its screw axis. Upward flow natively carries a −x planar bias, downward flow +x. Chirality isn't injected into this lattice's physics; the discrete 12-port geometry supplies it for free.

• Wraparound contamination measured. ~40% of collision mass was recycling through the periodic x/y boundary. The engine's torus lets spray leave +x and re-enter −x, returning into the other knot's mask from behind (visible in collide-symmetric_swapped VTK ~frame 28). An absorbing sponge (absorb_margin, applied pre-tick alongside pinch: quanta=0, buffer=0, heat>>=1 on the outer shell, drained mass counted as absorbed. The missing-transverse-energy channel) re-ran the y-mirror pair under an open boundary. The verdicts flip quantitative and qualitative: absorb_axis1 retain 0.2433 / 0.2437 vs wrapped 0.3109 / 0.3160, absorb_axis5 retain 0.2292 / **0** vs wrapped 0.3146 / 0.3193. Knot B is completely destroyed in axis5 once recycled debris stops re-accreting into its mask, and ~1.02M of the 2.51M initial mass was measured transiting the sponge in both runs. The earlier "symmetric degraded ~31%" was inflated by wrapped spray; the clean regime shows stronger and more directional asymmetry. Substrate chirality survives and sharpens when the contamination channel is closed. Mass budget now closes: massEnd + absorbed + in-arena dissipation accounts for all of mass0.

• GPU S-Matrix at scale, the lattice-locking verdict replicates, and the "collision" matrix measured something else: an absorbing-wall kill zone. The CUDA runtime (src/smatrix) ran its first full campaign, 32 scenarios × 256³ = 536M nodes, 1000 ticks, absorb_margin=8, diss=15, limit=50000, constant pinch 20. Submitted over LAN to an RTX 3060 (3.22 GB streamed job, ~0.6 s/tick, sprayEvents=0, absorbed=34.5M). Offline dual-BFS classification (script/smatrix_classify.mjs, 26-connectivity, meta-sidecar provenance masks) produced three regimes that resolve cleanly once centroid drift is inspected: (a) frozen pairs. 12 batches (all self_/x32_ at clearance ≥ ~31 from the walls) exit t1000 with mass byte-identical to spawn, 100% painted retention, zero unpainted live cells, and drift = 0.0, the knots never moved and never eroded, pure fixed points; (b) eroded pairs, 12 batches at clearance ≤ ~22 decay to a conspicuously uniform ~0.26 mass plateau with ~22–28% skeleton retention and an accreted unpainted debris halo, independently, without the components ever meeting; (c) spawn-contact, the 4 touch_* cases (born merged) decay as fused single bodies to the same plateau. The classifier's "elastic_bounce" labels are honest component arithmetic but scientifically mean no interaction: under canonical T_RATE=0 semantics the tension-gradient force is identically zero (gx=gy=gz=0), so pinch walls cannot propel. Lattice-locking confirmed at full scale on independent hardware. The mechanism is wall clearance, not seed stability: hopfion_24_20 is frozen at clr=37 (batch 16) but eroded at clr=22 (batch 4). The drain shell's effective reach is ~22–37 cells, eating each knot's extended breathing halo. This retroactively explains the CPU absorb differential's ~0.24 retention: the diagonal-axis spawn clipped ~40% of painted cells inside the margin at t=0. Wound-induced decay to the same plateau, not collision physics. Survival controls (single giants at clr 9–11) confirm the boundary: skeleton retention 0–30%, including one complete skeleton death (surv_64_16, retainA=0.0000) leaving a live 70k-cell debris body. Design consequence: real head-on collisions cannot be produced by separation+pinch on this substrate. Future matrices need contact-spawn, overlap-at-spawn, or momentum injection at load time, and margin-aware clamps must keep knot halos ≥ ~40 cells from absorbing walls (or the drain itself becomes the experiment).

The Contact-Dynamics Campaign (GPU S-Matrix v2)

With propulsion falsified, the v2 matrix (config/smatrix-v2.json, jobs 7–8) manufactured interactions at load time instead: spawn-overlap grids, arc/bite wounds, wounded×intact re-tie attempts, buffer kicks, mass-packet slugs, and force-driven emitter modulation. All on the compact hopfion_32_8 at 256³, absorb_margin=8, 1000 ticks. The run survived a host restart mid-flight: script/smatrix_resume.mjs splices pulled .smxst snapshots back into a job's state section (the dump format is the input-plane format), so t250→t1000 continued as job 8 without re-running. Verdicts below are from four classified snapshots per batch (t250/500/750/1000).

• Wall kill-zone is halo-geometry, not a fixed drain reach. The full clearance sweep (clr09–clr40) exits t1000 byte-identical, live=20952, 100% painted retention, freeEnds=0, including clr09 at 9 cells from the absorbing margin. v1's hopfion_24_20 died at clr≤22 and surv_64_16 died outright at clr~10, so the "~22–37 cell drain reach" was a property of fat-torus halos, not the sponge: what matters is whether a knot's live breathing halo (wider than its painted skeleton) touches the margin. hopfion_32_8's halo fits in <9 cells; the margin itself has no long-range appetite. Margin safety = seed-specific halo clearance, measurable per seed before matrix layout.

• Contact is binary: any overlap → fused amorphous debris, plateau ~0.23. The overlap grid (self-pairs at 2%/25%/50%/75% overlap, plus hopfion_32_8×{24_8, 40_8, 48_16} partners at 25%) all converge to the same state by t250: one merged body, painted retention 0.19–0.25, freeEnds ≈ live, maxCycle ≤ 2, no surviving cycles, no re-tied structure, insensitive to overlap fraction and partner size. Even 2% overlap annihilates both knots' topology: there is no grazing-incidence regime; the elastic_bounce channel is empty at every impact parameter that makes contact. The separated-axis control (ov_self_ax6, same pair spawned along FCC axis 6 so they never touch) stays frozen at 100%/100% through t1000: the trigger is contact alone.

• Arc wounds self-heal at scale; bites do not. wound_arc40/wound_arc50 (40%/50% contiguous arc cut from the parent cycle) both reclose by t250: freeEnds=0 at every snapshot, the 2001-cell cycle restored, painted retention 0.95–0.99 with slow peripheral debris shed, consistent with the CPU anneal campaign's ~0.55–0.6 closure threshold bracketing ≤0.5. wound_bite30 (a spatial 30% chunk removed, not a cycle-respecting arc) never heals: stable 0.166 debris. Topology repairs cycle-compatible wounds; spatial mutilation kills: the repair mechanism reads spin-chain continuity, not mass deficit.

• Re-tying falsified: topology cannot be grafted across knots. Wounded×intact (retie_arc40), double-wounded (retie_2x40), and bitten×intact (retie_bite30) pairs in forced 25% overlap all end as fused debris. maxCycle ≤ 2 at every snapshot, zero closed structure. An intact partner's phase-locked circulation does not template a wound closed, and contact does not splice strands. Sharpens the nucleation verdict: the lattice repairs near-complete topology within one provenance; it neither invents topology from flux nor merges it across bodies.

• Momentum injection works where pinch failed: kicks and slugs destroy topology, differing only in leftover debris. kick_iso (buffer=120 on every knot cell) → 0.355 painted retention; kick_hemi (−x hemisphere filter) → 0.294, but maxCycle ≤ 2 in both: the knot is dead, the remnant is debris sitting on painted sites, not a damaged-but-living structure. Directionality doesn't spare it. The energy dump is what wounds. The slug scenarios paint a 24-cell, w=4 mass packet 16 cells upstream aimed +x: slug_soft (q=80) → 0.0029, slug_hard (q=255) → 0.0066. Near-total scouring, the first destruction channel driven by an incoming object rather than ambient decay. Counterintuitively the harder slug leaves more debris: consistent with thermal blowoff scaling (a bigger deposit unwinds faster and clears sooner) rather than deeper penetration; flag for a dedicated q-sweep.

• Emitter modulation shows an alternating debris-retention parity: real frequency dependence, but on the remnant, not the knot. A force-driven disc (r=6, [60,128,128], +x at the knot) injecting quant=8 on a 50%-duty square wave (p0 = continuous at quant=4. Matched average flux) leaves painted-site retention of p0 → 0.0024, p4 → 0.237, p8 → 0.0001, p16 → 0.241, p32 → 0.0003, but maxCycle ≤ 2 in every case: the knot dies under all five drives, and what the parity selects is whether a ~0.24 debris plateau survives on the skeleton sites or the site is scoured to ~zero. Non-monotonic and not a dose curve (continuous drive at half the quant rate still scours; absorbedPer shows 683k–812k emitter-fed mass drained in all five). The drive period couples to whether remnant mass can settle at all, a real spectral feature of the erosion dynamics, not a knot-resonance survival window. Follow-up: dense mod sweep (p2–p64 + duty variation) to map the plateau/scour boundary.

• Radiator interim verdict. Chiral routing redistributes mass but doesn't outdrain. The chiral-metasurface experiment (block spraying isotropically through force-painted routing slabs: dumb wall, port-4 normal, port-8 chiral, port-11 antichiral; 89k spray events, 22.8M quanta) showed in-flight mass beyond the slab favoring chiral 2.7× over antichiral at every timepoint. But new per-batch absorbed counters give cumulative drain within ~6%: normal 1.20M > chiral 1.17M > antichiral 1.16M > dumb 1.13M. The routing difference is where mass pools, not delivered flux: sponge absorption is the bottleneck, and isotropic spray means the slab only ever sees the −x fraction. A decisive test needs face-resolved absorbed counters or a directed spray source.

• Transport + resume engineering. The campaign's infra fixes are load-bearing for all future runs: SMXZ block-gzip container (embedded public-domain puff.c in http.cpp) compresses job files 200–620× (v2: 3.2 GB → 5.2 MB) making LAN submission seconds not hours; the listener resumes job IDs from a directory scan on restart (no more pull collisions); smatrix_resume.mjs + dump_every give checkpoint-restart for free since .smxst dumps are bit-exact input planes; direct ethernet + absorbedPer per-batch counters round out observability. GPU contention caveat discovered the hard way: the docs deploy pipeline's Kokoro TTS shares the 3060. Deploy.yml is now path-filtered and the audio pipeline made incremental (content-hash sidecars + actions/cache), so code pushes no longer starve physics runs. A second infra bug was deeper: the push accumulator emulated u16 adds via packed-u32 atomicCAS retry loops, under sustained emitter spray the retry storms wedged the GPU with zero forward progress (job 9). Widening the push plane to u32/cell with native atomicAdd removed the only unbounded path in the kernel: the identical v3 job then ran at full ~0.6 s/tick.

The Grazing-Capture Campaign (GPU S-Matrix v3)

Can flux rushing past a knot feed it, where a direct hit kills? config/smatrix-v3-graze.json (job 13): the same emitter beam swept across impact parameters around hopfion_32_8, a flat xy-torus (81×80×17 skeleton, halo <9 cells), face-grazes (gz*, beam offset +z over the flat face), rim-grazes (gy*, offset +y edge-on into the annulus), and an 8-emitter co-rotating ring at radius 56 firing tangentially in the knot's plane, both chiralities.

• Feed vs. kill is a pure geometry boundary, and the fed side doubles the knot's mass. Face-grazes that still overlap the skeleton (gz04–gz12, beam center ≤14 cells past the face) destroy the knot exactly like the dead-center beam (retainA ~0 or the 0.23 debris plateau, maxCycle ≤ 2). Face-grazes that clear it (gz16–gz36) leave the knot fully intact, 100% painted retention, the 2001-cycle closed, with ~21k extra live cells pooled in a diffuse near-plane wake biased downstream of the beam (mass 1.95M vs 1.26M unfed): captured emitter flux, not survivor debris. Rim-grazes kill at every offset tested. The kill/feed boundary is geometric, not energetic: a beam can pass arbitrarily close over the flat face and feed, but cannot clip the rim edge-on at any price.

• The co-rotating ring is a feeding channel: a live entrained torus, phase-locked into the knot's basin. All four ring variants (cw/ccw × continuous/p4) exit t1000 with the knot intact (retainA=1.0000, cycles=14/2001) and ~61k–68k live cells. 3× the unfed mass (2.24M vs 1.26M). The captured mass maps as a planar torus: every unpainted live cell sits in the mid-plane band (|z−128|<12), peaked at r≈50–60, the injection orbit, and of 63k live cells only ~330 are free ends. Per-cycle membership is exact: all 14 cycles are byte-identical painted cells. No captured cell ever joins or spawns a closed loop. The disk is an open tributary network draining into the knot's cycles, not part of them. CCW nominally captures ~7% more live mass than CW (67.9k vs 63.4k): a weak handedness asymmetry, not yet decisive (n=1 per arm; needs the y-mirror parity control). Of ~7.2M injected mass, ~1M entrained (~14%; the rest crossed to the sponge).

• Emitter-off continuation (job 14) falsifies accretion. The torus is a pumped structure, and persistence ≡ closure. Resuming ring_cw_p0, ring_ccw_p0, gz16_p0, and ctl_nofeed from t=1000 with the force table stripped (v4: smatrix_resume.mjs --batches --forces=0, 500 ticks, dumps every 25): every unpainted cell drains to exactly zero. The halo decays linearly at ~280 cells/tick (ring, ~175 ticks to empty; face-graze wake, ~200) and stops dead at the painted boundary, where the knot holds 20,952 cells forever with freeEnds back to 0. Drain geometry is inside-out: the dense near-knot tributaries (r50–110) empty first, their flux had been flowing toward the cycles, while far-flung spray cells (r130–170) sit deadlock-frozen at identical counts for ~100 ticks before evaporating near-simultaneously. No bound fraction, no plateau above baseline, no splicing into cycles. And none was needed: the unfed control holds byte-identical mass the whole time. The corrected picture: tangential flux does not accrete onto the knot; it forms a live, phase-locked flow-through structure organized by the knot's wake while the pump runs, persistent only as long as injected. The sharpened law: closed loops are the only self-sustaining structures; open flow structures are transient no matter how perfectly phase-locked. What the ring actually demonstrated is a non-destructive coupling channel (the knot entrains grazing flux instead of being killed by it), not a growth channel.

• Assisted-annealing test (job 15). Driven flux cannot knit open ends: the sheath is dynamically decoupled from topology. config/smatrix-v5-arc.json pairs the v3 ring feed (cw/ccw) against two wound geometries on hopfion_32_8: arc_A (keep only a contiguous fraction of the longest cycle. A bare open chain, anneal-style) and wound_A (cut that arc, rest of knot intact). Results at t=1000: arc50_ctl erodes linearly ~1 painted cell/tick (pLive 1001→901→751→501→251→1). And arc50_cw/arc50_ccw produce byte-identical decay counts (901/751/501/251/1) behind a 42–47k-cell live halo: the driven sheath neither rescues nor accelerates the fraying. wound30/50 controls shed the broken arc at the same ~1 cell/tick while the 13 surviving cycles sit untouched, and the ring-fed twins are identical again (pLive 19,352 = 19,352 exactly). The feed does not help a wounded knot re-tie either. The one transient: arc60_cw formed a 207-cell cycle containing 33 unpainted cells at t=100. Initially read as catalyzed closure, but the v7 control proved it endogenous: the identical loop (207 cells, +33 unpainted) forms at t=50 in arc60_noring with zero emitters. It's the arc's own bleed transiently re-tying during initial unwind, not driven synthesis, and it dissolves by t=250 regardless. Verdict: external laminar flux does not scaffold open ends into closure. Topology repair/synthesis stays an internal matter. The substrate's closed/open boundary is sharp and drive-immune, consistent with the drain result: only closed loops persist, and nothing fed from outside gets closed.

• Arc–arc contact retying (job 16). Open ends never grow; they only fray, at a universal ~1 cell/tick regardless of context. config/smatrix-v6-arcrety.json splits the longest 2001-cycle into complementary halves (ranged arc: [start, frac] on the cycle index, dual-mask provenance) and spawns them in place with junction gaps of 0/5/10/20/40 cells. The seam0 control holds perfectly. A painted seam is indistinguishable from authored closure (2001-cycle, A1001+B1000, bit-stable 1000 ticks). But every gapped pair frays identically: painted counts decay ~1 cell/tick per arc, the same rate as the isolated bare arc (v5) and the wound-shed arcs, with zero bridging events at any gap size (5 cells is already infinitely far). A ~140-cell unpainted deposit forms at the junctions early then sits deadlock-frozen while the chains die around it. Asymmetric end detail: one arc's remnant stalled at ~127 cells (freeEnds=1, no cycle, a dying pocket), the other hit 0. Combined with v5: open chains cannot extend, bridge, or be induced to close. The tip's outbound flux dissipates into the gap rather than actualizing its next cell. Topological synthesis on this substrate has exactly one mechanism: closure at authoring time.

• Fray mechanics (jobs 17–19). The starvation clock is diss-independent and one-ended. Bare arc isolates (arc50/arc25 of the longest cycle) run at diss=5, 15, 30 produce byte-identical decay curves (arc50: 951→751→551→351→151→1). The ~1 cell/tick fray is not thermal evaporation; it's a structural starvation wave. Per-end tracking (v6 dumps) shows it consumes the arc only from the upstream tip, the end with no spin-chain predecessor, while the downstream tip bleeds flux into a ~140-cell frozen deposit yet never dies (cells starve on missing inflow, not failed outflow). Rate is segment-dependent (~2 cells/tick over the first ~500 cycle indices, arc25 dies by ~t300, vs 1/tick later) and locally modulated: remnants stall at ~127 cells inside debris-pocket recirculation zones.

• Quiet-sheath rerun (job 20), dose controls halo stability, never saves the bridge. arc60 under ring doses q1/q2/q4 (vs arc60_noring control): the 207-cycle transient forms identically in all four, including zero feed, then dies by t=250 in all four. Halo stability is dose-dependent: q1 stays orderly (freeEnds ~1,352), q2 frays at the edges (6.3k), q4 blows out into the 34k-freeEnd debris state seen in v5. The catalyzed-closure reading is fully retracted: the only transient retying observed was endogenous, an arc's own shed flux briefly closing a sub-loop, and no external dose makes it persist.

• Passive spectroscopy found the knot's heartbeat: a ~4-tick heat-channel oscillation. The smx-spectro job (4 unfed knots at 128³, 250 dumps at Δt=2; script/smatrix_spectro.mjs aggregates per-cell |FFT|² over painted masks) returns a sharp ~4-tick period in the heat field for every knot, sp_32_8, sp_24_8, sp_40_8 all show it, while a far-field control region is flat broadband noise. A margin-eroding knot (sp_48_16, too big for the arena) shows the same peak while bleeding 2.1M mass. The mode rides the topology, not the boundary condition. This plausibly is the v2 parity mechanism: p4 drives at the mode, p16 at its 4th subharmonic, while p8/p32 interleave against it. Debris survives when drive phases nest into the breathing rhythm. Next resonance experiment: drive the co-rotating ring at p4 vs neighboring periods and watch whether capture efficiency peaks. And add a per-emitter phase byte to the force record if phased-array wavefronts become worth building.

• The dense-bath test (job 22, v8). A sustained wind tunnel destroys knots; the vacuum wasn't hiding formation, it was the only survivable regime. config/smatrix-v8-bath.json asks the question raised by the model's own claim that vacuum is an active substrate, not empty space: a 2,809-emitter plane at x=24 injects +x flux at quant=4/cell/tick, continuous, driving a sustained non-equilibrium bath across the 256³ volume to the far sponge. Four scenarios run inside it (bath_only, bath_knot, bath_arc50, bath_gap10) against two vacuum controls (vac_knot, vac_arc50). The bath establishes cleanly: bath_only reaches steady state by t≈250. 3.15M live cells (18.8% occupancy, ~5.6 q/cell), the front sweeping the grid in ~200 ticks, ~6M quanta/batch drained at the sponge. It is 100% open flow, freeEnds frozen at 14,045 and zero cycles at every dump: dense flux alone still never self-closes, now measured at ~150× the occupancy of prior campaigns. The bath kills the knot. bath_knot is intact at t50 (14 cycles, maxCyc 2001, before the front arrives at x≈88–168), then unravels in ~100 ticks once engulfed: painted retention 20,483→13,739→5,451 by t200, maxCyc 2001→302→≤4. The kill is windward-first, the x64–128 bins collapse at t150 while the downstream half is still near-full, and the painted centroid stays pinned at x≈129–130 throughout: the knot does not drag or surf; lattice-lock holds while the structure is shredded. ~5,050 painted cells (24%) persist on the original footprint as bath-sustained live stragglers. A warning that painted-alive is not structure: the cycle census is the verdict, and it shows nothing closed. vac_knot is byte-identical all 20 dumps. No rescue for open chains: bath_arc50 retains 290 painted live cells at t1000 vs vacuum's 1. But those are cells kept live on ambient supply, not a surviving chain (cycles=0; the free-end signal drowns in the bath background). bath_gap10 decays identically (→293), maxCyc≤4. Ambient flow does not bridge the gap. Caveat on scope: this is a unidirectional collision storm (continuous driven headwind), not an isotropic equilibrium bath. It falsifies "dense sustained flux supports topology" at this intensity, and combined with the v7 dose-response (lower drive = more orderly halo), the remaining dense-regime question is whether a weak or directionally neutral ambient leaves knots intact. Every tested path still returns the same selection rule: closure at authoring, or nothing.

• The quench + composite test (job 23, v9), condensation falsified, and a new structural law: closed cycles are dark. config/smatrix-v9-quench.json breaks the Hopfion monoculture two ways. Quench arm: hot random fill (spins/q randomized, heat 1000–1500) at 8/25/50% interior density, sponge margin as the cold sink, the thermodynamic condensation channel. The random init contains thousands of accidental dimers at t50 (979–1,471 cycles). And the census shows them eroding monotonically (→19–72 by t1000) while mass drains (33–46M quanta/batch absorbed) and live count grows (the soup dilutes outward). maxCyc=2 at every dump, at every density: nothing nucleates, nothing coalesces, nothing larger than a chance dimer ever exists. The formation question is now closed in every regime tested, vacuum isolation, driven bath, and cooling quench all return the same verdict. Composite arm: nest_24_64 (hopfion_24_8 concentric inside hopfion_64_8's throat, 27 cycles total) and pair_gap (tangent 32_8 pair, 28 cycles) are both byte-identical for 1,000 ticks. And the mechanism is the deeper result: a closed in-degree-1 cycle consumes all of its own flux output, so disjoint knots exchange nothing. There is no force at a distance on this substrate. Matter interacts only through cell contact (touch/fusion, v2) or a shared external medium (v8's shredding bath). Disjoint closed structures are mutually invisible, which makes multi-body "physics" trivially stable and marks a fundamental limit of the model as a physics candidate: no gravity, no Coulomb analog, only contact and shared-bath coupling.

• The shared-medium coupling test (job 24, v10). Dark knots DO interact through a carrier: the upstream knot shadows the downstream knot's supply. config/smatrix-v10-shadow.json puts two hopfion_32_8 knots in a +x grazing-beam corridor (357-cell rect emitter at x=40, face-graze z-offset, q=4). A at x≈102, B at x≈198, plus single-knot and beam-only controls. All knots stay fully intact (14 cycles / maxCyc 2001, 100% painted retention). The interaction is in the mass budget: beamA corridor mass = beam0 + knot exactly; beamB holds +419k quanta of pooled trap mass beyond that; beam2 lands exactly at beam0 + 2×knot. Non-additive redistribution. x-profiles show the mechanism: each knot dams quanta in its near-field (A traps ~113k excess halo; B alone traps ~515k and sheds a 10× downstream plume), and with A upstream, B's trapped pool drops ~27% (1.36M vs 1.77M). The upstream knot consumes trapping capacity the stream would otherwise deliver to B. This is the first non-contact, non-destructive, directional knot↔knot coupling measured: not a force (centroids never move, structure untouched), but mutual influence at a distance through a shared carrier. Two filters in one stream competing for throughput. The v9 "dark knot" law stands in vacuum; a driven medium makes the darkness navigable.

• Transverse-induction prototype (+curl, native RFC). The discrete Biot-Savart term is real, produces a measurable spin aura, and still fails the closure litmus. Motivation: the canonical tick accumulates momentum only from flux arriving at a cell (mx -= V3[d]*sent), a passing jet exerts zero torque on lateral observers, the proposed missing mechanism behind both falsified properties (open-arc starvation and knot darkness). Implementation (flag-gated, off by default, planck3_set_curl(div, vac)): a neighbor firing along ns with ns != BACK3[d] contributes (V3[ns] × V3[BACK3[d]]) * sent >> (8+div) to the observer's momentum accumulator. J×r in fixed-point, reusing the existing dom→spin re-aim. vac=1 restricts the torque to spinless cells so authored topology cannot be perturbed. Regression gate: the hopfion_32_8 knot at t400 is byte-identical to baseline under +curlv at every strength tested (div 3/5/7). While ungated +curl destroys it (mass 1.68M → 167k, 372k flat-vs-chunk diffs), confirming the vacuum gate is mandatory, not cosmetic. The field exists: induced aura = s>0, q=0 cells aligned by passing flux. 30,838 cells in the knot's interstitial volume (knot mass untouched), 265k–354k cells around open arcs. A current really does organize the vacuum around it; the dark-knot law now has a nuance. Knots radiate a spin pattern, just not flux. The gap litmus fails: gap5 (2001-cycle minus a 5-cell bridge) and arc (1,000-cell open chain) under +curlv show the opposite of closure. Live cells triple (2,990 vs 1,137) as exhaust spreads into induced channels, freeEnds explode 4× (2,775 vs 628), mass retention worsens (82k vs 94k baseline at t300), and nCycles=0 at every strength. The mechanism is structural, not parametric: J×r aligns each vacuum cell into circulation around its local jet segment. A return path from tail-tip back to head-tip is a global topology the local rule cannot synthesize. Shed mass dilutes into the aura and drains instead of freezing in a puddle (deadlocked cells drop to ~0. The one real effect), but dispersal is not return. Verdict: the induction law is a genuine new field-mediated coupling on vacuum cells, it survives its regression gate, and the "forgotten mechanic closes the gap" hypothesis is falsified at first test. Gap05 needs a mechanism that acts on endpoint topology, not lateral circulation.

• Tension-gradient pull test (T_RATE>0, native RFC). The self-attraction channel is live, safe for uniform topology by symmetry, and fails the gap litmus for a structural reason that now looks like a theorem. g_t_rate makes the dormant compile-time pull runtime-settable: at the hash-lottery duty, a live+spun cell adds ∇tn (up-gradient, gx += V3[d]*(np_tn − tn)) to its momentum. Gate detail that decides the physics: feelsTension = (cq>0 && cs!=0). only structured cells feel the pull; vacuum is blind to the field. Tension is emitted by mass (q+b > T_EMIT_MIN), so the channel is gravity-like self-attraction toward dense regions. not a conduit toward the starving head (the head emits nothing; emptiness is not a tension sink). Regression gate: the hopfion_32_8 knot is byte-identical at duty 128. And the reason is a clean symmetry: uniform density ⇒ gd ≈ 0 everywhere ⇒ the pull only bites at tension boundaries (edges, deposits, wounds), never inside a plateau structure. Gap litmus fails again: gap5 at duty 128/255 → 1,777/1,747 live, freeEnds 1,567/1,532, nCycles=0 (one incidental 4-cycle at 255), mass 71k/55k vs 94k baseline. Worse on every axis, plus the first flat-vs-ordered mass divergence seen (order-sensitivity = the pull makes outcomes history-dependent). arc at 128: 954 live, 30k mass (baseline: 720/50k). The structural statement the two RFCs earn: gap closure is a global constraint. Some gap cell must aim at the specific cell that is the head, and nothing local marks the head as special: its tension is low (starving ⇒ no emission), its spin points away (downstream), its address is invisible. +curlv organizes circulation around flux but can't aim at an endpoint; T_RATE aims at density peaks but the head is a density void. Every local field tested so far answers "where is flux/density". Closure needs "where is the missing predecessor," and no channel in the engine expresses that. This is now the honest open problem: either a rule that marks demand (a free-end signal), or closure stays authored-only.

• Helmholtz-analog tests (native). Wall termination and contact reconnection both fail, each for a mechanism-specific reason that tightens the closure law. Two classical ways topology persists/changes without authored loops were tested on the 100×100×40 native rig (states via script/p3st_emit.mjs --column / --xlink; census p3st_census.mjs). Wall-terminated column: a 40-cell open filament spanning z=0→39 by port-7 steps. The Helmholtz "vortex may end on a boundary" case. It frays anyway: the upstream tip starves identically to a free-space arc (~slower: 40→15 live cells by t300), ending at t1200 as ~10 cells of q≈250 s=0 deadlocked deposit piled against the ceiling wall, the wall relocates the corpse but doesn't anchor it. Cause: the engine has no boundary-termination semantics. A spin pointing through a hard z-surface (key[d]<0, no channel) is simply a free end, so the filament still has a starving upstream tip. X-reconnection: two copies of the 2001-cycle routed to share exactly two junction cells P,Q (loop B BFS-routed externally through free space; --xlink=200,1200). Three ownership assignments cover the splice space. And all three die by t400 (cycles=0): own-A (intact loop A + two robbed B strands → A dies), own-B (closed 120-cell B loop + robbed A arcs → B dies), and the true partner-swap (P spins B-dir, Q spins A-dir → a mixed-provenance hybrid cycle of exactly the predicted 1,061 cells exists at t0. And still dies). Control: the lone 2001-ring alone is byte-identical at t400, so the kills are not lone-ring fragility. The mechanism is self-poisoning: in every splice, the robbed strands' tails terminate at the junction cells. Their exhaust lands directly on P/Q, whose dom gets scrambled by the injected momentum (v8's windward-kill physics at a single point). Real reconnection ejects surplus vorticity as radiation; here the discarded branches are hardwired to dump onto the splice. Combined with the parity discovery: HOFF offsets are y-parity-dependent, so translation by odd Δy is not a graph isomorphism (a shifted copy garbles into 1150 free ends at t0; only even-Δy moves preserve shape). The substrate now has no demonstrated channel for topology change after authoring: not field-induced (curl/trate), not condensation (v9), not feeding (v5–v8), not contact splicing (this).

• Universal-induction reconciliation (native). The s==0 gate is removable: universal +curl preserves the knot two independent ways, and both are the physically-motivated ones. The all-cells kill mechanism was confirmed as same-streamline self-torque: a loop cell's own neighbors torque its dom >60° off cs, breaking Phase Lock from inside. Two fixes, both tested on hopfion_32_8 at t300: (a) α-strength self-coupling. Universal curl at div=7 (~1/128 of inflow momentum) leaves the knot byte-identical and produces the full 30,838-cell aura; self-field does work only at this weak scale, matching the EM intuition that self-interaction is perturbative, not shredding. (b) Collinear screening. A new g_curl_scr bit skips induction when the receiver's spin is already aligned with the jet (DOTS[ns][cs] >= 128, the same cone as Phase Lock): at div=5 the knot is byte-identical with the full aura; at div=3 screening is insufficient alone (286k mass, still lethal). A current's own field can't torque it sideways only holds for co-flowing neighbors, and the knot's fold geometry presents anti-parallel/oblique neighbors too. gap05 under universal curl fails identically (div7-universal and div5-screened: ~3.2k live, ~2.9k freeEnds, 0 cycles, ~355k aura), universality doesn't fix the global-topology problem, as predicted. Net: the RFC now has a uniform law, planck3_set_curl(5, 2) or (7, 0), where every node runs the same operator and authored topology survives by physics (weak coupling / alignment screening), not by a provenance check. The vacuum-only mode remains available as the maximally-safe variant.

• Claim validation pass (native): two Gemini inferences graded against byte-level data, and both need correction. (a) "α must be weak" is overclaimed. Byte-diffing the spin plane vs baseline shows universal curl at div4/5/6/7 changes zero knot cells. The only diffs are the 30,838-cell vacuum aura. The knot doesn't tolerate weak self-torque; it never resolves any: structured cells' own inflow (~256·sent per predecessor) always wins the dom argmax until the induced term can outvote it, which happens only at div3 (1/8). The real kill threshold sits between 1/8 and 1/16. A lattice-anisotropy bound on torque-vs-transport ratio, not a fine-structure analog; 1/128 ≈ 1/137 is numerological coincidence. The deeper consequence: every survivable universal coupling is observationally vacuum-only. The aura only ever forms on spinless cells regardless of the gate. The s==0 "hack" turns out to be a description of where this field can exist at all, not an artificial exemption. (b) "Asymmetric exhaust = reaction propulsion" is falsified at first test, and the reason is architectural. Momentum in planck3_node_tick is registered only at the receiver (mx -= V3[d]*sent on the incoming side); the sender loses q and feels nothing. There is no recoil channel anywhere in the engine. Newton's third law is absent by construction. The knot_vent test (5,517 cells on the −x face repointed to fire −x at q=255, t=300): the knot dies (cycles=0, 19k free ends) and the live-cell centroid moves −x (50.75→46.68), the direction of firing, not the recoil direction, because what moved is the ejecta cloud, not a surviving structure. There is no core displacement and no reconstitution: severed waveguide → wound → debris, consistent with every prior wound result. Honest conclusion for the kinematics question: motion is not expressible in the current register set. No drift register (rejected), no recoil channel, no re-form-ahead regrowth. If particles move on this substrate it requires a mechanism not yet invented, not just not yet measured.

• Mechanics-audit RFCs (native): un-muting tension and adding recoil both answer, and neither unlocks what was hoped. Two dormant/asymmetric mechanics promoted to runtime knobs (planck3_set_temit, planck3_set_recoil) after the fD3Q13/FCHC lineage review identified them as the engine's gaps vs the lattice-gas tradition. T_EMIT_MIN 200→40 is lethal, not liberating. At threshold 40, knot cells (q=60) emit tension. And the knot dies (mass 1.68M→129k at t300, worse with trate: 102k). The kill channel is T_DIVERT: once the knot is a tension source, its boundary gradient shears its own circulation into up-gradient buffers. T_EMIT_MIN=200 wasn't muting a gravity field. It was protecting topology from its own emission. Tension in this engine is a congestion pathology signal by design; making it a mass-potential turns it into a self-poison. gap5 under temit40+trate128: 41k mass, 6,184 freeEnds, 0 cycles. Worst result in the entire matrix. g_recoil is real and knot-safe, but observably inert where structure lives. Sender recoil (mx -= V3[cs]·(sent>>g_recoil)) at 1/4 and 1/8 leaves hopfion_32_8 byte-identical. Newton's third law is now in the engine and the knot shrugs it (recoil is sub-dominant to inflow momentum wherever the waveguide is balanced). Where it IS observable is unbalanced emitters: knot_vent+recoil loses more mass than no-recoil (124k vs 399k). Recoiling vent cells turn around and fire back into the interior, deepening the wound. Centroid of the debris moves +1.03 toward +x vs no-recoil, a residue-distribution shift on a dead structure, not propulsion. The audit's net law: every added coupling is either sub-dominant (inert on topology) or destructive. There is no observed intermediate regime where a new force acts on structure without breaking it. That's the sharpest statement yet of why this substrate is static: the phase-lock cone + inflow dominance means any field strong enough to move a cell is strong enough to kill it.

• Integer flux partitioning (native RFC), the mechanic implements cleanly in the existing 6-byte node, fires correctly, and still doesn't dissolve the binary cliff: the leak is radiation, not deflection. The proposal (Peierls–Nabarro relief): split each cell's outflow between primary port and a secondary port chosen by the suppressed deflection. 105q along v₁ + 5q along v₂ gives ~2.7° effective bend without snapping the loop. Encoding: the uint8_t spin packs two 4-bit ports (p1 | p2<<4). Zero register growth, legacy states compatible (high nibble 0). Receivers pull sent − sent>>g_split on the primary channel and sent>>g_split on the p2-aligned channel; mass-conserving when both land. v1 falsified the trigger: keying p2 off dom leaked on the knot's own curvature (incoming momentum naturally sits off-axis on a bent loop) → 321k mass at t300. Fix: separate field-momentum accumulators (fx/fy/fz. Curl + tension pull only); p2 = field direction only when phase lock holds ns2==cs while a field pulls elsewhere. v2 mechanics all verified: dormant without field (byte-identical at split3+duty64), and the quantization floor is real. Split7 gives 60>>7 = 0 leak per tick, so a hash-lottery g_split_duty (same pattern as g_t_rate) time-multiplexes activation for effective rates duty/256 × 2^-split. The litmus fails at every rate: knot + curl5-screened + split3 → duty255: 510k/4cyc, duty64: 306k/1cyc, duty16: 343k/0cyc at t300, dead at all nonzero leak rates, and non-monotonic in duty (chaotic death trajectory, not dose-response). gap5+trate128+split3d64: 66k, 0 cycles. Why the physics model was wrong: the 105/5 split only deflects the trajectory if the 5q rejoins the structure. But on this substrate the trajectory IS the spin graph. The 5q land on an off-loop vacuum cell and die there; they add mx to that cell (nucleating aura spin) but cannot pull the waveguide, because bending the loop means re-assigning successor spins, exactly what phase lock forbids. Flux partitioning buys a continuous radiation rate knob, not a continuous deflection angle. The PN-barrier reframing: the cliff isn't momentum quantization. It's that the waveguide path is discrete at the topology level. Shedding mass off-structure is now tunable; moving structure remains inexpressible.

---

The M1–M31 grounded-measurement campaign entries were removed from this page. That campaign exhaustively characterized a single-spin prototype node (uint8_t spin): an implementation constraint, not the substrate's target physics. The multichannel findings on meso3i.c that carry forward are preserved in The Multi-Channel Bridge; the full campaign record remains in git history.