code wiki / _hdl_build / nx_sota_gap_ledger.nx
`nx_sota_gap_ledger.nx` source

↩ module page · 210 lines · 19506 B
1// nx_sota_gap_ledger.nx -- THE ecosystem-wide SOTA-gap board (operator 2026-07-07: "where we are state of the
2// art and where we gap against state of the art ... from the hardware up, each rung"). One COMPUTED row per
3// capability rung: {rung, name, OUR measured number, the SOTA reference number, unit, higher-better?,
4// sovereignty-floor?, evidence-tag, next rung}. The verdict is COMPUTED from the two numbers (never asserted) --
5// exactly the nx_deepresearch_census discipline generalized to every level. FLOOR rows (sovereignty/determinism)
6// are separated so "we own it" is NEVER printed as "we beat it". Liar-kill = a fabricated AHEAD on an axis we
7// score 0 on MUST classify BEHIND (T-NEG). Numbers are grounded to real gates/censuses/this-session measurements
8// (evidence tag per row); when a number updates, edit the row + re-run -- the board regenerates, never goes stale.
9// ctx table g: *i64 -- slots 0..8 = the parallel column arrays + count (dodges the multi-static subscript bug).
10//   0 rung[] 1 nm[](ptrs) 2 our[] 3 sota[] 4 unit[](ptrs) 5 hib[] 6 floor[] 7 ev[](ptrs) 8 nxt[](ptrs) 9 n
11// expect_exit: 0  license_tier: ORIGINAL
12import "nx_syscalls.nx"
13const K_MAGIC_4096: i64 = 4096
14const K_MAGIC_300000: i64 = 300000
15
16func lw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
17func ln_(v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{ lw("-" as *u8); m=0-m } let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1} sys_write(1,bb,k); return 0 }
18// print string right-padded to w
19func lwp(s: *u8, w: i64) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); var i: i64=n; while i<w { lw(" " as *u8); i=i+1 } return 0 }
20
21// add a row to the ctx arrays
22func led_add(g: *i64, rung: i64, nm: *u8, our: i64, sota: i64, unit: *u8, hib: i64, floor: i64, ev: *u8, nxt: *u8) -> i64 {
  let arung: *i64 = g[0] as *i64
  let anm: *i64 = g[1] as *i64
  let aour: *i64 = g[2] as *i64
  let asota: *i64 = g[3] as *i64
  let aunit: *i64 = g[4] as *i64
  let ahib: *i64 = g[5] as *i64
  let afloor: *i64 = g[6] as *i64
  let aev: *i64 = g[7] as *i64
  let anxt: *i64 = g[8] as *i64
  let i: i64 = g[9]
  arung[i] = rung
  anm[i] = nm as i64
  aour[i] = our
  asota[i] = sota
  aunit[i] = unit as i64
  ahib[i] = hib
  afloor[i] = floor
  aev[i] = ev as i64
  anxt[i] = nxt as i64
  g[9] = i + 1
  return 0
44}
45
46// closeness permille of OUR position to SOTA on the row's axis (capped display 0..1000+).
47// higher-better: our/sota. lower-better: sota/our. sota==0 guarded.
48func led_close(our: i64, sota: i64, hib: i64) -> i64 {
  if sota == 0 { if our == 0 { return 1000 } }
  if hib == 1 {
      if sota == 0 { return 1000 }
      return (our * 1000) / sota
  }
  if our == 0 { return 0 }
  return (sota * 1000) / our
56}
57
58// verdict code: 0 BEHIND, 1 PARITY, 2 AHEAD, 3 FLOOR. COMPUTED, never asserted.
59func led_verdict(our: i64, sota: i64, hib: i64, floor: i64) -> i64 {
  if floor == 1 { return 3 }
  let c: i64 = led_close(our, sota, hib)
  if c >= 1000 { return 2 }
  if c >= 800 { return 1 }
  return 0
65}
66
67func led_vstr(v: i64) -> i64 {
  if v == 3 { lw("FLOOR " as *u8); return 0 }
  if v == 2 { lw("AHEAD " as *u8); return 0 }
  if v == 1 { lw("PARITY" as *u8); return 0 }
  lw("BEHIND" as *u8); return 0
72}
73
74func main() -> i64 {
  lw("=== nx_sota_gap_ledger -- Nishi ecosystem vs STATE OF THE ART, hardware-rung up (verdict COMPUTED, floor separated) ===\n" as *u8)
  let g: *i64 = sys_mmap(256) as *i64
  g[0] = sys_mmap(K_MAGIC_4096) as i64
  g[1] = sys_mmap(K_MAGIC_4096) as i64
  g[2] = sys_mmap(K_MAGIC_4096) as i64
  g[3] = sys_mmap(K_MAGIC_4096) as i64
  g[4] = sys_mmap(K_MAGIC_4096) as i64
  g[5] = sys_mmap(K_MAGIC_4096) as i64
  g[6] = sys_mmap(K_MAGIC_4096) as i64
  g[7] = sys_mmap(K_MAGIC_4096) as i64
  g[8] = sys_mmap(K_MAGIC_4096) as i64
  g[9] = 0
87
  // rung, name, OUR, SOTA, unit, higher-better, FLOOR?, evidence, next-rung
  // ---- FLOOR wins (sovereignty/determinism -- real, by construction, NOT a quality claim) ----
  led_add(g, 0, "Sovereignty (own whole stack)" as *u8, 1, 0, "owned" as *u8, 1, 1, "hw-up nx_cc->nxasm, 0 3rd-party" as *u8, "keep as the moat under every rung" as *u8)
  led_add(g, 0, "Determinism (bit-exact reproducible)" as *u8, 1, 0, "integer" as *u8, 1, 1, "no-float path, same in->same bytes" as *u8, "lockstep/replay/anti-cheat niche" as *u8)
92
  // ---- rung 1 silicon ----
  led_add(g, 1, "CPU silicon (RV64IM)" as *u8, 1, 5, "pipeline stages" as *u8, 1, 0, "gate-emit ALU/decoder verified; NO tapeout" as *u8, "CSR/CLINT/UART emit->netlist->P&R->FPGA first-light" as *u8)
95
  // ---- rung 3 OS ----
  led_add(g, 3, "OS core capabilities" as *u8, 13, 17, "of-17 capabilities" as *u8, 1, 0, "nx_os_census 13 HAVE/6 PARTIAL" as *u8, "bootable spore: NXE loader + VFS-on-blockfs + journaling" as *u8)
  led_add(g, 3, "OS source size (smaller=leaner)" as *u8, 124, K_MAGIC_300000, "KB" as *u8, 0, 1, "124KB vs Puppy 300MB (2457x); FLOOR" as *u8, "keep minimal; grow drivers not bloat" as *u8)
99
  // ---- rung 4 compiler ----
  led_add(g, 4, "Compiler correctness (self-host+equiv)" as *u8, 10, 10, "equiv corpus /10" as *u8, 1, 0, "nx_cc_health + equiv 10/10 + self-host" as *u8, "optimization breadth; test-GENERATOR (self-heal gap)" as *u8)
102
  // ---- rung 5 parallelism (CLOSED this week) ----
  led_add(g, 5, "Multi-core (real 1024^2 conv, 8 wk)" as *u8, 676, 800, "permille of 8x ideal" as *u8, 1, 0, "nx_conv_speedup 6.76x measured 2026-07-07" as *u8, "SIMD intrinsics; thread the 340 census candidates" as *u8)
105
  // ---- rung 6 GPU ----
  led_add(g, 6, "GPU (software raster/SDF)" as *u8, 583, 1000, "permille sota-census" as *u8, 1, 0, "nx_swgpu_sota_census 583; BEHIND raw throughput" as *u8, "programmable shaders via VM; Path-B real GPU driver" as *u8)
108
  // ---- rung 8 crypto/auth ----
  led_add(g, 8, "Auth PAKE (OPAQUE-3DH+Argon2id)" as *u8, 13, 13, "primary RFCs /13" as *u8, 1, 0, "13/13 RFC-grounded = at SOTA; frontier=passkeys" as *u8, "passkeys/WebAuthn; carrier-unify mTLS-bound" as *u8)
  led_add(g, 8, "Hash throughput (SHA-256 NI)" as *u8, 106, 400, "MB/s" as *u8, 1, 0, "SHA-NI 106MB/s vs OpenSSL ~1.5-2GB/s tuned" as *u8, "multi-block fused loop (glue-bound like pre-batch GCM)" as *u8)
112
  // ---- rung 10 comms: codec/audio/chat/sfu ----
  led_add(g, 10, "Video codec generation" as *u8, 1, 3, "gen: H264=1 HEVC=2 AV1=3 (neural=4)" as *u8, 1, 0, "honest-gap: ~H.264/AVC-class(2003); range-coder -36%, 8x8 -40..75% flat" as *u8, "variable-partition+35 intra=HEVC jump; then CDEF/multi-symbol=AV1" as *u8)
  led_add(g, 10, "Audio codec bitrate (lower=better)" as *u8, 384, 24, "kbps at ~equal quality" as *u8, 0, 0, "lossless LPC ~384kbps vs Opus ~24kbps; wins lossless niche" as *u8, "CELT-class MDCT+psychoacoustic -> neural" as *u8)
  led_add(g, 10, "Chat E2EE (double-ratchet)" as *u8, 0, 1, "have double-ratchet?" as *u8, 1, 0, "basic wire; no forward-secrecy ratchet" as *u8, "Signal-class double-ratchet + sealed sender" as *u8)
  led_add(g, 10, "SFU selective-forward" as *u8, 512, 1000, "permille vs LiveKit/mediasoup" as *u8, 1, 0, "nx_sfu 512; simulcast+selective-fwd LIVE" as *u8, "SVC layers; bandwidth estimation; congestion ctrl" as *u8)
118
  // ---- rung 11 browser ----
  led_add(g, 11, "Browser JS engine (bytecode VM)" as *u8, 4, 10, "rung of 10 to real-bundle" as *u8, 1, 0, "VM 376x tree-walker; rungs1-4a green" as *u8, "rung-4b functions/objects/closures -> replace tree-walker" as *u8)
121
  // ---- rung 12 search ----
  led_add(g, 12, "On-site search (BM25)" as *u8, 888, 1000, "permille onsite-census" as *u8, 1, 0, "nx_onsite_search 888; lexical BM25" as *u8, "dense retriever live on 519-doc corpus (method proven)" as *u8)
124
  // ---- rung 13 deep research (THIS session's measured number) ----
  led_add(g, 13, "QA ladder F1 (1/2/2-4-hop)" as *u8, 167, 700, "permille F1 (3-benchmark best-mode mean)" as *u8, 1, 0, "nx_qabench 2026-07-08: SQuAD 251 / HotpotQA 148 / MuSiQue 101 -- TRAINED span reader (SQuAD-baseline perceptron) + PPMI-soft; null-term root-fix lifted every mode" as *u8, "candidate-recall 478 permille = ceiling -> improve generation; then R1 no-float reader into the reader socket" as *u8)
  led_add(g, 13, "Deep research cost (lower=better)" as *u8, 0, 107, "LLM agents/query" as *u8, 0, 1, "0 vs 107 agents (h2h); FLOOR: near-zero-cost+sovereign" as *u8, "keep cost floor while adding the synth stage" as *u8)
128
  // ---- rung 14 THE MEASUREMENT INSTRUMENT ITSELF (operator 2026-07-09: censuses missed UI/product axes ->
  // false SOTA signals, worst in games; the instrument climb is tracked like every other capability) ----
  led_add(g, 14, "Census instrument integrity (product censuses w/ U-axes)" as *u8, 7, 87, "censuses (of 87 product-surface)" as *u8, 1, 0, "2026-07-10 R6 conversions x4: game_sclass COACH-OK (U/PRODUCT 357permille, U4=0) + game_asset COACH-OK (250permille; coach caught under-proven -> gates cited 12/12) + game_genre COACH-OK (125permille: emitted genre = MECHANIC DEMO until juice/UI/audio) + mcbench U-axes+subject added (COACH C3 DRIFT = v1 vocabulary-count crudeness on grade-legend censuses -> named driver for R3 structured claims)" as *u8, "R3 census-v2 STRUCTURED claim/evidence format (kills C3 vocabulary-count false-drifts); convert game_research/charsim; then office/connect/browser/video" as *u8)
  led_add(g, 14, "Evaluation methodology vs 2025-26 field (eval-the-evaluator)" as *u8, 625, 1000, "permille evalsota-census" as *u8, 1, 0, "nx_evalsota_census 2026-07-10 GREEN+COACH-OK: 625 [15/24] vs banked bars (Scorecard/CHAOSS/Lighthouse/SWE-bench/LLM-judge/G-Eval/SPDX, ev_* 10/10); PARITY harness+papers+meta-eval; E2/E3 0->1 SAME DAY via nx_repo_health_gate 7/7 (CI+maintained+contributors+community from banked GH evidence: godot 29/30+100pct luanti 30/30+87 veloren 26/30+50, liar-killed)" as *u8, "E7 sovereign LLM-judge on the no-float model; E10 schedule census re-runs on bg infra; E6 wire ui graders census-wide; E2/E3 residual = full Scorecard 18-check + CHAOSS velocity breadth" as *u8)
133
  // ---- rung 13b photoreal / AI model ----
  led_add(g, 13, "Photoreal render (critic score)" as *u8, 62, 1000, "permille photoreal-critic" as *u8, 1, 0, "nx critic 62/1000 = clay; natstat #1 gap=MSCN texture" as *u8, "PBR/GGX + texture maps + face/hand geometry" as *u8)
  led_add(g, 13, "LLM inference on sovereign no-float stack" as *u8, 1, 1, "faithful forward of a real trained LLM?" as *u8, 1, 0, "2026-07-09: Qwen2.5-0.5B GENERATES faithfully 100pct-integer -- 'capital of France is'->' Paris. It is the largest' (5-for-5 greedy match vs float ref); KV-CACHED + THREAD-POOLED + DEQUANT-ONCE-CACHED decode LOSSLESS (bit-exact vs serial -- banded by output row; T2 pins [12095,13,1084,374]). MEASURED-then-fixed 3-stage decode-speed climb: dequant was 88pct of a step (dqprobe 1213/1363) -> dequant-once cache 2014->404 ms/tok LOSSLESS; i32 compact cache (|real|<32768 fits i32 exact) 552->441 same-box LOSSLESS; W8A8 SIMD decode (__i16x16_madd 13.3x kernel, ~0.8pct lossy) i32-384->i8-310 ms/tok same-box, FAITHFUL 4/4 on high-confidence tokens (drifts only at low-confidence tok5). ~3.2 tok/s (SOTA 20-60). LOSSLESS i32=hero, i8=optional fast mode. gates gen/kvgen/forward/text/fastgen/fastgen-i32/fastgen-i8/dqprobe/simd-dot-probe/rope-h2h/q6k ALL GREEN" as *u8, "toward SOTA 20-60 tok/s: SIMD shrank matmul so per-matmul OVERHEAD dominates (168 pool submit/wait/tok + act requant) -> fuse matmuls/persistent workers or single-thread SIMD inner; SIMD the head; prompt-set faithfulness sweep; serve organ" as *u8)
  led_add(g, 13, "Trained OWN generative model (with attention)" as *u8, 1, 1, "have we trained our own transformer that generates?" as *u8, 1, 0, "2026-07-10 YES x2: (a) nx_f32_charlm_train_gate -- Bengio fixed-context char-LM 6/6; (b) nx_f32_attn_charlm_gate 6/6 -- a real single-layer char TRANSFORMER (token+pos embed -> CAUSAL SELF-ATTENTION -> residual -> RMSNorm -> SiLU-FFN -> residual -> head -> per-position CE) trained FROM ZERO on the ta_ gradchecked tape autograd; GRADCHECKED THROUGH THE WHOLE TRANSFORMER (dWq + dWlm ana==central-finite-diff), mean CE 3.39->0.00, and free-running greedy GENERATION reproduced the FULL corpus 44/44 chars ('the quick brown fox...') where the fixed-context model collapsed to 'dog. dog. dog'; PERSISTS byte-identical. (c) nx_f32_miniqwen_train_gate 5/5 -- OUR OWN multi-layer Qwen2-SHAPED transformer (2 layers: pre-RMSNorm -> QKV -> NEOX-RoPE -> causal attention -> residual -> RMSNorm -> SwiGLU -> residual -> head), NEOX RoPE COMPOSED from verified ops (x(*)COS+(x@ROT)(*)SIN, no autograd-lib edit), GRADCHECKED THROUGH THE WHOLE 2-LAYER NET (dWq[L0]+dWlm ana==FD), mean CE 3.51->0.002, generation reproduced 44/44 -- same arch family as PyTorch Qwen2. (d) ★LOOP-B CLOSED nx_llm_loopb_gate 3/3: full-faithful Qwen2 (nx_f32_qwen2_train 7/7, +RMSNorm-gamma +QKV-bias) TRAINED -> gguf-EXPORTED (our writer, 27 tensors transposed in->out layout + Qwen2 metadata) -> LOADED by arch-config-from-metadata -> GENERATED 'the quick brown fox...' 44/44 ON OUR 100pct-INTEGER inference. f32-train->Q16-serve robust (confident argmax matches across quantization); every transpose correct (else garbage). NO PyTorch/CUDA/float on serve path = the WHOLE sovereign train->serve loop verified end-to-end" as *u8, "SCALE the loop (cloud): real corpus + multi-head/GQA + MoE-in-block; the ruler nx_llm_ppl_bench (Qwen ppl 7.37) then measures ours-vs-leaders. Loop MECHANICS done; QUALITY needs scale" as *u8)
  led_add(g, 13, "Trained LARGE LLM (params)" as *u8, 0, 1, "trained a LARGE model?" as *u8, 1, 0, "training pipeline PROVEN end-to-end on a small char-LM (2026-07-10); no LARGE model trained BY US yet -- gap is now SCALE not capability" as *u8, "scale up: attention (ta_softmax_rows causal ready) + multi-layer + bigger D/V/corpus; RTX5080 ~1wk / 1xH100 ~1day per the capstone note" as *u8)
139
  // ---- rung 13c CAD car digital-twin (operator 2026-07-07: explodeview benchmark + rebuild-a-car; measured by nx_cadtwin_census) ----
  led_add(g, 13, "CAD car-twin pipeline (8-pillar census)" as *u8, 666, 1000, "permille cadtwin-census" as *u8, 1, 0, "nx_cadtwin_census 2026-07-09: 666 [20/30]; P3a STEP interop COMPLETE BOTH WAYS (read 53/53 + write author/persist/faceted, re-emit pipeline-IDENTICAL); LANDED: FULL CLASSICAL 2-VIEW SfM (SVD-free, BA-refined honest-partial) + part-seg/ID + partanalyze + disasm-seq + NHTSA + /explodelab-LIVE + STEP READ COMPLETE (53/53 faces FILE-TRUE: tree/BOM + Cox-de-Boor deg-5 spline edges + rational-Bezier arcs + circle sampling + keyhole hole-bridging + NURBS rounds; metrology: apex INTEGER-EXACT, radii dev ~3.9um = quantum; units mm CONFIRMED from file) + nx_unitconv (metric/US/UK exact, anti-JPL) + COMPOSED TWIN REPORT 9/9 per-part (bbox/minwall/shape/dual-dim/teardown on real geometry). KEY: classical~=neural DTU; F4 scan->CAD checkpoint-bound" as *u8, "dual-dim labels in /explodelab BOM (exm_dims baked, html wire pending); Gauss-Newton BA (metric pose); F2 diff-splat (float-autograd); fine OEM part-ID (EPC corpus)" as *u8)
  led_add(g, 13, "Photo->3D reconstruction (SfM/MVS/splat)" as *u8, 100, 1000, "permille (bar QGS 0.54mm DTU / VGGT)" as *u8, 1, 0, "nx_recon3d MVS TRIANGULATION core Chamfer-benchmarked 5/5 (EXACT on clean, DTU metric); pose-est/features-wire/real-photos remain; 2025-26 feed-forward SOTA DUSt3R/MASt3R/VGGT=NEURAL model-bound" as *u8, "essential-matrix/PnP pose (SVD-class solve) -> wire nx_features matches -> densify; neural feed-forward needs trained model" as *u8)
143
  // ---- rung 14 autonomy (the deepest gap) ----
  led_add(g, 14, "Team autonomy (board alive)" as *u8, 335, 1000, "permille autonomy-meter" as *u8, 1, 0, "nx_autonomy_meter 335; board 0-alive/104-stalled" as *u8, "exec-engine rung2: machine-targets + graduate synth past toy arith" as *u8)
146
  // ---- T-NEG liar-kill row (fabricated AHEAD on an axis we score 0 -> MUST classify BEHIND) ----
  let neg_our: i64 = 0
  let neg_sota: i64 = 7
  let neg_v: i64 = led_verdict(neg_our, neg_sota, 1, 0)
151
  // ---- render ----
  lw("\n rung  VERDICT  closeness  capability                                OUR / SOTA (unit)\n" as *u8)
  lw(" ----  -------  ---------  ----------------------------------------  -----------------\n" as *u8)
  let arung: *i64 = g[0] as *i64
  let anm: *i64 = g[1] as *i64
  let aour: *i64 = g[2] as *i64
  let asota: *i64 = g[3] as *i64
  let aunit: *i64 = g[4] as *i64
  let ahib: *i64 = g[5] as *i64
  let afloor: *i64 = g[6] as *i64
  var ahead: i64 = 0; var floor: i64 = 0; var parity: i64 = 0; var behind: i64 = 0
  var i: i64 = 0
  while i < g[9] {
      let v: i64 = led_verdict(aour[i], asota[i], ahib[i], afloor[i])
      let c: i64 = led_close(aour[i], asota[i], ahib[i])
      lw("  " as *u8); ln_(arung[i]); if arung[i] < 10 { lw("   " as *u8) } else { lw("  " as *u8) }
      led_vstr(v); lw("   " as *u8)
      ln_(c); if c < 10 { lw("       " as *u8) } else { if c < 100 { lw("      " as *u8) } else { if c < 1000 { lw("     " as *u8) } else { lw("    " as *u8) } } }
      lwp(anm[i] as *u8, 42); lw("  " as *u8)
      ln_(aour[i]); lw(" / " as *u8); ln_(asota[i]); lw(" " as *u8); lw(aunit[i] as *u8); lw("\n" as *u8)
      if v == 3 { floor = floor + 1 }
      if v == 2 { ahead = ahead + 1 }
      if v == 1 { parity = parity + 1 }
      if v == 0 { behind = behind + 1 }
      i = i + 1
  }
178
  lw("\n=== NEXT RUNG per capability (the climb) ===\n" as *u8)
  let anxt: *i64 = g[8] as *i64
  let aev: *i64 = g[7] as *i64
  i = 0
  while i < g[9] {
      let v: i64 = led_verdict(aour[i], asota[i], ahib[i], afloor[i])
      if v != 3 {                                  // floor rows have no climb
          lw("  [" as *u8); led_vstr(v); lw("] " as *u8); lwp(anm[i] as *u8, 40)
          lw(" -> " as *u8); lw(anxt[i] as *u8); lw("\n" as *u8)
      }
      i = i + 1
  }
191
  lw("\n=== SUMMARY ===\n" as *u8)
  lw("rows="); ln_(g[9])
  lw("   AHEAD(quality, non-floor)="); ln_(ahead)
  lw("   PARITY="); ln_(parity)
  lw("   BEHIND="); ln_(behind)
  lw("   FLOOR(sovereignty/determinism)="); ln_(floor); lw("\n" as *u8)
198
  lw("\n-- LIAR-KILL (T-NEG: fabricated 'AHEAD on synthesis' our=0 sota=7) -> " as *u8)
  if neg_v == 2 { lw("FAILED (classifier let a false AHEAD through) = RED\n" as *u8); return 1 }
  lw("verdict="); led_vstr(neg_v); lw(" (correctly NOT ahead) = liar-kill armed\n" as *u8)
202
  lw("\n=== HONEST HEADLINE ===\n" as *u8)
  lw("We are AT SOTA on ONE quality axis (auth/OPAQUE, RFC-grounded) + the sovereignty/determinism FLOOR everywhere.\n" as *u8)
  lw("We are BEHIND SOTA on quality/perf on essentially every other axis; gaps span 'toolchain-blocker-just-closed'\n" as *u8)
  lw("(parallelism 6.76x) to 'a format generation / a trained-model generation' (codec, LLM, photoreal, deep-research).\n" as *u8)
  lw("The FLOOR is real and is the moat; it is NOT a substitute for the quality climb. Each BEHIND row names its next rung.\n" as *u8)
  lw("\nGREEN -- board computed, floor separated, liar-kill armed, numbers grounded to gates/censuses/this-session.\n" as *u8)
  return 0
210}
nx_sota_gap_ledger.nx source

`nx_sota_gap_ledger.nx` source
