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

↩ module page · 870 lines · 45843 B
1// nx_arch_board.nx -- THE TEAM'S STANDING JUDGMENT OF THE FAMILY TREE (operator 2026-07-16: "get the nishi
2// team and architect and builder and pm and all that logically evaluating our family tree and making sure
3// we are doing state of the art architecture"). This is the ARCH DRIFT RATCHET rung (mom 13) of the
4// ecosystem-design review, built as a COMPOSER: it fork+execs the existing sovereign instruments (small
5// sharp tools -> curated capability, per the mcp-coverage doctrine) and adds the two metrics no instrument
6// carried (visibility violations = rung mom-29; validation depth = rung mom-22; base-change advisory =
7// rung mom-3). Every metric row is DATA-DRIVEN (knowledge/registry/arch_policy.data: metric|role|weight|
8// direction|target) and RATCHETED against a banked baseline (knowledge/registry/arch_baseline.data):
9// improvements tighten the limit automatically, so erosion can never be silent -- limit = min(target,
10// baseline) for `le` metrics, max for `ge`. Each row is attributed to the accountable ROLE (architect/
11// janitor/examiner/...), and the failing rows sorted by momentum-weight ARE the PM's ranked worklist.
12// Composes (never rebuilds): nx_eco_graph_arch (cycles/propagation/fan-in) + nx_dup_detect (fused dup
13// clusters) + nx_eco_rooted_set (islands) + nx_capability_placement (RACI placement violations).
14//   nx_arch_board gate                                    -- adversarial self-test of the ratchet verdict
15//   nx_arch_board run  <store-prefix> [core-dir] [organ-dir]   -- judge; exit 0 GREEN / 1 RED
16//   nx_arch_board bank <store-prefix> [core-dir] [organ-dir]   -- judge + bank baseline (refuses on any
17//                                                                instrument failure -- never bank a broken measurement)
18// license_tier: ORIGINAL   module: nishi-core.architect.arch_board
19import "nx_syscalls.nx"
20import "nx_eco_graph.nx"
21import "nx_seg_store.nx"
22const AB_MAGIC_2166136261: i64 = 2166136261
23const AB_MAGIC_16777619: i64 = 16777619
24const AB_MAGIC_4611686018427387903: i64 = 4611686018427387903
25const AB_MAGIC_4294967295: i64 = 4294967295
26const AB_MAGIC_65536: i64 = 65536
27const AB_MAGIC_12345: i64 = 12345
28const AB_MAGIC_99999: i64 = 99999
29const AB_MAGIC_262144: i64 = 262144
30const AB_MAGIC_1000003: i64 = 1000003
31const AB_MAGIC_131072: i64 = 131072
32const AB_MAGIC_16384: i64 = 16384
33const AB_MAGIC_1048576: i64 = 1048576
34
35const AB_ZSLOTS: i64 = 65536
36const AB_ZARENA: i64 = 2097152
37const AB_OUTCAP: i64 = 1048576
38const AB_MAXROW: i64 = 32
39// verdicts
40const AB_PASS: i64 = 1
41const AB_RED: i64 = 2
42const AB_NOTICE: i64 = 3
43// metric-value indices (mv array)
44const MV_CYCLES: i64 = 0
45const MV_AVGDEP: i64 = 1
46const MV_FANIN: i64 = 2
47const MV_VIS: i64 = 3
48const MV_VAL: i64 = 4
49const MV_ISL: i64 = 5
50const MV_DUP: i64 = 6
51const MV_PLACE: i64 = 7
52const MV_BASEH: i64 = 8
53const MV_ISLU: i64 = 9
54const MV_DP: i64 = 10
55const MV_N: i64 = 11
56
57func ab_p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
58func ab_pn(v: i64) -> i64 {
  var m: i64 = v; if m < 0 { ab_p("-" as *u8); m = 0 - m }
  let t: *u8 = sys_mmap(24); 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 }
  let o: *u8 = sys_mmap(24); var i: i64 = 0; while i < k { o[i] = t[k-1-i]; i = i + 1 } sys_write(1, o, k)
  sys_munmap(t, 24); sys_munmap(o, 24); return 0
64}
65func ab_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
66func ab_streq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 } if b[i] != (0 as u8) { return 0 } return 1 }
67// equality of buf[ao..ao+al) against NUL-terminated b (exact, both-terminate)
68func ab_memeq_s(a: *u8, ao: i64, al: i64, b: *u8) -> i64 {
  var i: i64 = 0
  while i < al { if b[i] == (0 as u8) { return 0 } if a[ao+i] != b[i] { return 0 } i = i + 1 }
  if b[al] != (0 as u8) { return 0 }
  return 1
73}
74// does buf[o..o+l) end with NUL-terminated suffix?
75func ab_ends(a: *u8, o: i64, l: i64, suf: *u8) -> i64 {
  let sl: i64 = ab_slen(suf)
  if l < sl { return 0 }
  var i: i64 = 0
  while i < sl { if a[o+l-sl+i] != suf[i] { return 0 } i = i + 1 }
  return 1
81}
82// append helpers for building page/baseline buffers
83func ab_bapp(b: *u8, pos: i64, s: *u8) -> i64 { var p: i64 = pos; var i: i64 = 0; while s[i] != (0 as u8) { b[p] = s[i]; p = p + 1; i = i + 1 } return p }
84func ab_bappn(b: *u8, pos: i64, v: i64) -> i64 {
  var p: i64 = pos; var m: i64 = v
  if m < 0 { b[p] = 45 as u8; p = p + 1; m = 0 - m }
  let t: *u8 = sys_mmap(24); 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 { b[p] = t[k-1-i]; p = p + 1; i = i + 1 }
  sys_munmap(t, 24); return p
91}
92// append buf[o..o+l) (raw bytes)
93func ab_bappb(b: *u8, pos: i64, src: *u8, o: i64, l: i64) -> i64 { var p: i64 = pos; var i: i64 = 0; while i < l { b[p] = src[o+i]; p = p + 1; i = i + 1 } return p }
94// bounded whole-file read (bounded-VSZ law: NEVER sys_read_file in organs)
95func ab_read_small(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var n: i64 = 0; var r: i64 = 1
  while r > 0 { r = sys_read(fd, (buf as i64 + n) as *u8, cap - 1 - n); if r > 0 { n = n + r } if n >= cap - 1 { r = 0 } }
  sys_close(fd)
  buf[n] = 0 as u8
  return n
103}
104func ab_write_file(path: *u8, buf: *u8, len: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, 420)
  if fd < 0 { return 0 - 1 }
  var off: i64 = 0
  while off < len { let w: i64 = sys_write(fd, (buf as i64 + off) as *u8, len - off); if w <= 0 { sys_close(fd); return 0 - 1 } off = off + w }
  sys_close(fd)
  return 0
111}
112func ab_fnv(buf: *u8, len: i64) -> i64 {
  var h: i64 = AB_MAGIC_2166136261
  var i: i64 = 0
  while i < len { h = h ^ (buf[i] as i64); h = (h * AB_MAGIC_16777619) & AB_MAGIC_4611686018427387903; i = i + 1 }
  return h
117}
118// substring search: return index just AFTER key, or -1
119func ab_find(buf: *u8, blen: i64, key: *u8) -> i64 {
  let kl: i64 = ab_slen(key)
  if kl == 0 { return 0 - 1 }
  var i: i64 = 0
  while i + kl <= blen {
      var m: i64 = 1
      var j: i64 = 0
      while j < kl { if buf[i+j] != key[j] { m = 0; j = kl } else { j = j + 1 } }
      if m == 1 { return i + kl }
      i = i + 1
  }
  return 0 - 1
131}
132// parse digits starting exactly at pos; -1 if none
133func ab_num_at(buf: *u8, blen: i64, pos: i64) -> i64 {
  if pos < 0 { return 0 - 1 }
  var v: i64 = 0; var any: i64 = 0; var i: i64 = pos
  var go: i64 = 1
  while go == 1 {
      if i >= blen { go = 0 } else {
          let c: i64 = buf[i] as i64
          if c < 48 { go = 0 } else { if c > 57 { go = 0 } else { v = v * 10 + (c - 48); any = 1; i = i + 1 } }
      }
  }
  if any == 0 { return 0 - 1 }
  return v
145}
146func ab_num_after(buf: *u8, blen: i64, key: *u8) -> i64 { return ab_num_at(buf, blen, ab_find(buf, blen, key)) }
147// ---- SOVEREIGN STORE data plane (operator law 2026-07-16: organ data lives in knowledge/store/
148// seg-stores, NEVER new flat .txt/.tsv/.data -- the two-copy trap). The board OWNS its store
149// (producer-writes-own-data law): keys policy / baseline / fixtures / worklist. ----
150func ab_store_get(key: *u8, lenout: *i64) -> *u8 {
  let po: *i64 = sys_mmap(16) as *i64
  let lo: *i64 = sys_mmap(16) as *i64
  let r: i64 = ss_get("knowledge/store/archboard-" as *u8, key, po, lo)
  if r != 1 { lenout[0] = 0 - 1; return 0 as *u8 }
  lenout[0] = lo[0]
  return po[0] as *u8
157}
158func ab_store_put(key: *u8, val: *u8, vlen: i64) -> i64 {
  let w: *i64 = ss_begin()
  if ss_add(w, 1, key, val, vlen) != 0 { return 0 - 1 }
  let sid: i64 = ss_next_segid("knowledge/store/archboard-" as *u8)
  if sid < 0 { return 0 - 2 }   // 0 = valid FIRST segid on a fresh store (absent manifest)
  return ss_commit("knowledge/store/archboard-" as *u8, w, sid)
164}
165// is pat[po..po+pl) a substring of hay[ho..ho+hl)?
166func ab_contains(hay: *u8, ho: i64, hl: i64, pat: *u8, po: i64, pl: i64) -> i64 {
  if pl == 0 { return 0 }
  var i: i64 = 0
  while i + pl <= hl {
      var m: i64 = 1
      var j: i64 = 0
      while j < pl { if hay[ho+i+j] != pat[po+j] { m = 0; j = pl } else { j = j + 1 } }
      if m == 1 { return 1 }
      i = i + 1
  }
  return 0
177}
178// classify islands: for each line of ibuf, match against pattern lines of tbuf (`=name` exact, else
179// substring; # comments). Returns UNEXPLAINED count (prints first 10 -- the janitor's true worklist).
180func ab_islands_unexplained(ibuf: *u8, ilen: i64, tbuf: *u8, tlen: i64) -> i64 {
  var unex: i64 = 0
  var shown: i64 = 0
  var ls: i64 = 0
  var i: i64 = 0
  while i <= ilen {
      var eol: i64 = 0
      if i >= ilen { eol = 1 } else { if ibuf[i] == (10 as u8) { eol = 1 } }
      if eol == 1 {
          var e: i64 = i
          if e > ls { if ibuf[e-1] == (13 as u8) { e = e - 1 } }
          if e > ls {
              // scan patterns
              var matched: i64 = 0
              var pls: i64 = 0
              var pi: i64 = 0
              while pi <= tlen {
                  var peol: i64 = 0
                  if pi >= tlen { peol = 1 } else { if tbuf[pi] == (10 as u8) { peol = 1 } }
                  if peol == 1 {
                      var pe: i64 = pi
                      if pe > pls { if tbuf[pe-1] == (13 as u8) { pe = pe - 1 } }
                      if pe > pls { if tbuf[pls] != (35 as u8) {
                          if tbuf[pls] == (61 as u8) {
                              // exact: =name
                              if pe - pls - 1 == e - ls {
                                  var eq: i64 = 1
                                  var k: i64 = 0
                                  while k < e - ls { if tbuf[pls+1+k] != ibuf[ls+k] { eq = 0; k = e - ls } else { k = k + 1 } }
                                  if eq == 1 { matched = 1; pi = tlen }
                              }
                          } else {
                              if ab_contains(ibuf, ls, e - ls, tbuf, pls, pe - pls) == 1 { matched = 1; pi = tlen }
                          }
                      } }
                      pls = pi + 1
                  }
                  pi = pi + 1
              }
              if matched == 0 {
                  unex = unex + 1
                  if shown < 10 { ab_p("  [island-UNEXPLAINED] " as *u8); sys_write(1, ((ibuf as i64)+ls) as *u8, e - ls); ab_p("\n" as *u8); shown = shown + 1 }
              }
          }
          ls = i + 1
      }
      i = i + 1
  }
  return unex
229}
230
231// fork + exec instrument with stdout+stderr redirected to outpath (argv built IN THE CHILD -- the proven
232// fork law); parent waits. Returns child exit code, or -1 on fork/wait failure.
233func ab_exec_capture(bin: *u8, a1: *u8, a2: *u8, outpath: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid < 0 { return 0 - 1 }
  if pid == 0 {
      let av: *i64 = sys_mmap(48) as *i64
      av[0] = bin as i64
      var k: i64 = 1
      if (a1 as i64) != 0 { av[1] = a1 as i64; k = 2; if (a2 as i64) != 0 { av[2] = a2 as i64; k = 3 } }
      av[k] = 0
      let ev: *i64 = sys_mmap(16) as *i64
      ev[0] = 0
      let fd: i64 = sys_openat_wr(outpath, 420)
      if fd < 0 { sys_exit(112) }
      sys_dup3(fd, 1, 0)
      sys_dup3(fd, 2, 0)
      sys_execve(bin, av, ev)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  let r: i64 = sys_wait4(pid, st, 0)
  let code: i64 = (st[0] / 256) & 255
  sys_munmap(st as *u8, 16)
  if r < 0 { return 0 - 1 }
  return code
257}
258
259// ---- zone table: .nx basename -> zone (1=CORE runtime/, 2=ORGAN runtime/_hdl_build/, 3=AMBIGUOUS both) ----
260func abz_hash(s: *u8, o: i64, l: i64) -> i64 { var h: i64 = AB_MAGIC_2166136261; var i: i64 = 0; while i < l { h = h ^ (s[o+i] as i64); h = (h * AB_MAGIC_16777619) & AB_MAGIC_4294967295; i = i + 1 } return h }
261// insert name (from src[so..so+sl)) with zone; returns 3 if it became ambiguous, else zone
262func abz_insert(zoff: *i64, zzone: *i64, zlen: *i64, arena: *u8, aused: *i64, src: *u8, so: i64, sl: i64, zone: i64) -> i64 {
  var slot: i64 = abz_hash(src, so, sl) % AB_ZSLOTS
  if slot < 0 { slot = 0 - slot }
  var go: i64 = 1
  var res: i64 = zone
  while go == 1 {
      if zoff[slot] < 0 {
          let base: i64 = aused[0]
          var i: i64 = 0
          while i < sl { arena[base+i] = src[so+i]; i = i + 1 }
          arena[base+sl] = 0 as u8
          zoff[slot] = base; zlen[slot] = sl; zzone[slot] = zone
          aused[0] = base + sl + 1
          go = 0
      } else {
          if zlen[slot] == sl {
              var eq: i64 = 1
              var j: i64 = 0
              while j < sl { if arena[zoff[slot]+j] != src[so+j] { eq = 0; j = sl } else { j = j + 1 } }
              if eq == 1 { if zzone[slot] != zone { zzone[slot] = 3; res = 3 } go = 0 } else { slot = slot + 1; if slot >= AB_ZSLOTS { slot = 0 } }
          } else { slot = slot + 1; if slot >= AB_ZSLOTS { slot = 0 } }
      }
  }
  return res
286}
287func abz_get(zoff: *i64, zzone: *i64, zlen: *i64, arena: *u8, src: *u8, so: i64, sl: i64) -> i64 {
  var slot: i64 = abz_hash(src, so, sl) % AB_ZSLOTS
  if slot < 0 { slot = 0 - slot }
  var probes: i64 = 0
  while probes < AB_ZSLOTS {
      if zoff[slot] < 0 { return 0 }
      if zlen[slot] == sl {
          var eq: i64 = 1
          var j: i64 = 0
          while j < sl { if arena[zoff[slot]+j] != src[so+j] { eq = 0; j = sl } else { j = j + 1 } }
          if eq == 1 { return zzone[slot] }
      }
      slot = slot + 1; if slot >= AB_ZSLOTS { slot = 0 }
      probes = probes + 1
  }
  return 0
303}
304// scan a directory's .nx entries into the zone table; returns count (or -1 open fail)
305func ab_scan_dir(dir: *u8, zone: i64, zoff: *i64, zzone: *i64, zlen: *i64, arena: *u8, aused: *i64, ambig: *i64) -> i64 {
  let fd: i64 = sys_openat_rd(dir)
  if fd < 0 { return 0 - 1 }
  let buf: *u8 = sys_mmap(AB_MAGIC_65536)
  var cnt: i64 = 0
  var nr: i64 = 1
  while nr > 0 {
      nr = sys_getdents64(fd, buf, AB_MAGIC_65536)
      if nr > 0 {
          var o: i64 = 0
          while o < nr {
              let reclen: i64 = (buf[o+16] as i64) + ((buf[o+17] as i64) * 256)
              if reclen <= 0 { o = nr } else {
                  let dtype: i64 = buf[o+18] as i64
                  if dtype != 4 {
                      var nl: i64 = 0
                      while buf[o+19+nl] != (0 as u8) { nl = nl + 1 }
                      if nl > 3 { if ab_ends(buf, o+19, nl, ".nx" as *u8) == 1 {
                          if abz_insert(zoff, zzone, zlen, arena, aused, buf, o+19, nl, zone) == 3 { ambig[0] = ambig[0] + 1 }
                          cnt = cnt + 1
                      } }
                  }
                  o = o + reclen
              }
          }
      }
  }
  sys_close(fd)
  sys_munmap(buf, AB_MAGIC_65536)
  return cnt
335}
336
337// ---- ★THE PURE RATCHET VERDICT (gated): limit = min(target, baseline) for le / max for ge, so an
338// improvement, once banked, becomes the new floor -- erosion below a banked win is RED even when still
339// inside the policy target. ch = change-advisory (NOTICE on drift, for the base-change contract).
340// cur < 0 = instrument failure = RED (fail-closed: a broken measurement never passes). Unknown direction
341// = RED (fail-closed on policy typos).
342func ab_verdict(dir: i64, tgt: i64, hasbl: i64, bl: i64, cur: i64) -> i64 {
  if cur < 0 { return AB_RED }
  if dir == 1 { var lim: i64 = tgt; if hasbl == 1 { if bl < lim { lim = bl } } if cur <= lim { return AB_PASS } return AB_RED }
  if dir == 2 { var lim2: i64 = tgt; if hasbl == 1 { if bl > lim2 { lim2 = bl } } if cur >= lim2 { return AB_PASS } return AB_RED }
  if dir == 3 { if hasbl == 0 { return AB_PASS } if cur == bl { return AB_PASS } return AB_NOTICE }
  return AB_RED
348}
349// effective limit (for printing) -- must mirror ab_verdict's limit math
350func ab_limit(dir: i64, tgt: i64, hasbl: i64, bl: i64) -> i64 {
  if dir == 1 { if hasbl == 1 { if bl < tgt { return bl } } return tgt }
  if dir == 2 { if hasbl == 1 { if bl > tgt { return bl } } return tgt }
  return tgt
354}
355
356func ab_gate() -> i64 {
  ab_p("=== nx_arch_board GATE -- the ratchet verdict must be un-gameable ===\n" as *u8)
  var fail: i64 = 0
  if ab_verdict(1, 10, 0, 0, 7) == AB_PASS { ab_p("  [PASS] le within target, no baseline -> PASS\n" as *u8) } else { ab_p("  [FAIL] T1\n" as *u8); fail = 1 }
  if ab_verdict(1, 10, 0, 0, 11) == AB_RED { ab_p("  [PASS] le above target -> RED (policy floor holds)\n" as *u8) } else { ab_p("  [FAIL] T2\n" as *u8); fail = 1 }
  if ab_verdict(1, 10, 1, 5, 7) == AB_RED { ab_p("  [PASS] ratchet TEETH: banked 5 < target 10, cur 7 -> RED (a banked win may not erode, even inside target)\n" as *u8) } else { ab_p("  [FAIL] T3 ratchet-tighten\n" as *u8); fail = 1 }
  if ab_verdict(2, 600, 1, 750, 700) == AB_RED { ab_p("  [PASS] ge ratchet: banked 750 > target 600, cur 700 -> RED (depth may not drop below banked)\n" as *u8) } else { ab_p("  [FAIL] T4\n" as *u8); fail = 1 }
  if ab_verdict(3, 0, 1, AB_MAGIC_12345, AB_MAGIC_99999) == AB_NOTICE { ab_p("  [PASS] ch drift -> NOTICE (base-change contract advisory)\n" as *u8) } else { ab_p("  [FAIL] T5\n" as *u8); fail = 1 }
  if ab_verdict(9, 10, 0, 0, 1) == AB_RED { ab_p("  [PASS] unknown direction -> RED (fail-closed on policy typo)\n" as *u8) } else { ab_p("  [FAIL] T6\n" as *u8); fail = 1 }
  if ab_verdict(1, 10, 1, 5, 0 - 1) == AB_RED { ab_p("  [PASS] instrument failure (cur=-1) -> RED (a broken measurement never passes)\n" as *u8) } else { ab_p("  [FAIL] T7\n" as *u8); fail = 1 }
  if ab_verdict(1, 10, 1, 5, 4) == AB_PASS { ab_p("  [PASS] improvement under banked -> PASS (and bank tightens next)\n" as *u8) } else { ab_p("  [FAIL] T8\n" as *u8); fail = 1 }
  // T9 store round-trip: the sovereign data plane itself must prove put->get byte-exact each build
  var sok: i64 = 0
  if ab_store_put("gate_probe" as *u8, "ratchet-store-alive" as *u8, 19) == 0 {
      let glp: *i64 = sys_mmap(16) as *i64
      let gb: *u8 = ab_store_get("gate_probe" as *u8, glp)
      if glp[0] == 19 { if (gb as i64) != 0 {
          var geq: i64 = 1
          let gw: *u8 = "ratchet-store-alive" as *u8
          var gi: i64 = 0
          while gi < 19 { if gb[gi] != gw[gi] { geq = 0 } gi = gi + 1 }
          if geq == 1 { sok = 1 }
      } }
  }
  if sok == 1 { ab_p("  [PASS] sovereign-store round-trip (put/get byte-exact, seg-commit)\n" as *u8) } else { ab_p("  [FAIL] T9 store round-trip\n" as *u8); fail = 1 }
  if fail == 0 { ab_p("=== GATE GREEN: erosion cannot be silent -- improvements lock in, failures fail closed ===\n" as *u8); sys_exit(0); return 0 }
  ab_p("=== GATE RED ===\n" as *u8); sys_exit(1); return 1
383}
384
385// resolve policy metric name -> mv index (fail-closed: unknown -> -1 -> RED row)
386func ab_resolve(name: *u8, no: i64, nl: i64) -> i64 {
  if ab_memeq_s(name, no, nl, "cycles" as *u8) == 1 { return MV_CYCLES }
  if ab_memeq_s(name, no, nl, "avg_dependents" as *u8) == 1 { return MV_AVGDEP }
  if ab_memeq_s(name, no, nl, "base_fanin_pct" as *u8) == 1 { return MV_FANIN }
  if ab_memeq_s(name, no, nl, "visibility_violations" as *u8) == 1 { return MV_VIS }
  if ab_memeq_s(name, no, nl, "validation_depth_permille" as *u8) == 1 { return MV_VAL }
  if ab_memeq_s(name, no, nl, "islands" as *u8) == 1 { return MV_ISL }
  if ab_memeq_s(name, no, nl, "islands_unexplained" as *u8) == 1 { return MV_ISLU }
  if ab_memeq_s(name, no, nl, "flat_dataplanes" as *u8) == 1 { return MV_DP }
  if ab_memeq_s(name, no, nl, "dup_clusters" as *u8) == 1 { return MV_DUP }
  if ab_memeq_s(name, no, nl, "placement_violations" as *u8) == 1 { return MV_PLACE }
  if ab_memeq_s(name, no, nl, "base_hash" as *u8) == 1 { return MV_BASEH }
  return 0 - 1
399}
400func ab_vname(v: i64) -> *u8 { if v == AB_PASS { return "PASS" as *u8 } if v == AB_NOTICE { return "NOTICE" as *u8 } return "RED" as *u8 }
401
402// baseline lookup: rows "metric|value\n"; returns 1 + writes *out, else 0
403func ab_bl_get(bbuf: *u8, blen: i64, name: *u8, no: i64, nl: i64, out: *i64) -> i64 {
  var ls: i64 = 0; var i: i64 = 0
  while i <= blen {
      var eol: i64 = 0
      if i >= blen { eol = 1 } else { if bbuf[i] == (10 as u8) { eol = 1 } }
      if eol == 1 {
          if i > ls { if bbuf[ls] != (35 as u8) {
              var bar: i64 = 0 - 1
              var j: i64 = ls
              while j < i { if bbuf[j] == (124 as u8) { bar = j; j = i } else { j = j + 1 } }
              if bar > ls {
                  if bar - ls == nl {
                      var eq: i64 = 1
                      var k: i64 = 0
                      while k < nl { if bbuf[ls+k] != name[no+k] { eq = 0; k = nl } else { k = k + 1 } }
                      if eq == 1 { out[0] = ab_num_at(bbuf, blen, bar + 1); return 1 }
                  }
              }
          } }
          ls = i + 1
      }
      i = i + 1
  }
  return 0
427}
428
429// ---- the full judgment: measure -> judge -> rank -> page -> (bank) ----
430func ab_run(store: *u8, coredir: *u8, organdir: *u8, do_bank: i64) -> i64 {
  ab_p("=== NX ARCH BOARD -- the team's standing judgment of the family tree ===\n" as *u8)
  // 1) run the instruments (composition, not reimplementation)
  let x_arch: i64 = ab_exec_capture("./nx_eco_graph_arch.elf" as *u8, store, 0 as *u8, "logs/ab_arch.out" as *u8)
  let x_dup: i64 = ab_exec_capture("./nx_dup_detect.elf" as *u8, store, 0 as *u8, "logs/ab_dup.out" as *u8)
  let x_root: i64 = ab_exec_capture("./nx_eco_rooted_set.elf" as *u8, store, "logs/ab_islands.txt" as *u8, "logs/ab_rooted.out" as *u8)
  let x_plc: i64 = ab_exec_capture("./nx_capability_placement.elf" as *u8, "classify" as *u8, "knowledge/registry/crew_capabilities.data" as *u8, "logs/ab_place.out" as *u8)
  ab_p("[instruments] eco_graph_arch=" as *u8); ab_pn(x_arch)
  ab_p(" dup_detect=" as *u8); ab_pn(x_dup)
  ab_p(" rooted_set=" as *u8); ab_pn(x_root)
  ab_p(" placement=" as *u8); ab_pn(x_plc); ab_p(" (exit codes; 0=ok)\n" as *u8)
  // 2) parse instrument outputs
  let mv: *i64 = sys_mmap(MV_N * 8) as *i64
  var q: i64 = 0
  while q < MV_N { mv[q] = 0 - 1; q = q + 1 }
  let obuf: *u8 = sys_mmap(AB_OUTCAP)
  var on: i64 = ab_read_small("logs/ab_arch.out" as *u8, obuf, AB_OUTCAP)
  if x_arch == 0 { if on > 0 {
      mv[MV_CYCLES] = ab_num_after(obuf, on, "nontrivial SCCs=" as *u8)
      mv[MV_AVGDEP] = ab_num_after(obuf, on, "avg transitive dependents per organ=" as *u8)
      let fi: i64 = ab_find(obuf, on, "direct-importers=" as *u8)
      if fi >= 0 { let po: i64 = ab_find(obuf, on, "% of all organs)" as *u8); if po >= 0 { var ps: i64 = po - 17; var pd: i64 = ps; while pd > 0 { let c: i64 = obuf[pd-1] as i64; if c >= 48 { if c <= 57 { pd = pd - 1 } else { pd = 0 - pd } } else { pd = 0 - pd } } if pd < 0 { pd = 0 - pd } mv[MV_FANIN] = ab_num_at(obuf, on, pd) } }
  } }
  on = ab_read_small("logs/ab_dup.out" as *u8, obuf, AB_OUTCAP)
  if x_dup == 0 { if on > 0 { mv[MV_DUP] = ab_num_after(obuf, on, "CONFIRMED-dup-clusters>=2=" as *u8) } }
  on = ab_read_small("logs/ab_rooted.out" as *u8, obuf, AB_OUTCAP)
  if x_root == 0 { if on > 0 { mv[MV_ISL] = ab_num_after(obuf, on, "from-god-rooted (" as *u8) } }
  // island taxonomy (the janitor's judgment layer): raw islands minus classified compiler/gauntlet
  // fixtures = UNEXPLAINED islands. Fail-closed: no taxonomy file -> -1 -> RED (the taxonomy must exist).
  if x_root == 0 {
      let ibuf: *u8 = sys_mmap(AB_MAGIC_262144)
      let il: i64 = ab_read_small("logs/ab_islands.txt" as *u8, ibuf, AB_MAGIC_262144)
      let tlp: *i64 = sys_mmap(16) as *i64
      let tbuf: *u8 = ab_store_get("fixtures" as *u8, tlp)
      let tl: i64 = tlp[0]
      if il >= 0 { if tl > 0 { mv[MV_ISLU] = ab_islands_unexplained(ibuf, il, tbuf, tl) } }
      ab_p("[islands] raw=" as *u8); ab_pn(mv[MV_ISL])
      ab_p(" fixture-classified=" as *u8)
      if mv[MV_ISLU] >= 0 { ab_pn(mv[MV_ISL] - mv[MV_ISLU]) } else { ab_p("?" as *u8) }
      ab_p(" UNEXPLAINED=" as *u8); ab_pn(mv[MV_ISLU]); ab_p("\n" as *u8)
      sys_munmap(ibuf, AB_MAGIC_262144)
      // tbuf points INTO the store's read mapping (not a mapping base) -- no munmap; one-shot process
  }
  on = ab_read_small("logs/ab_place.out" as *u8, obuf, AB_OUTCAP)
  if x_plc == 0 { if on > 0 { mv[MV_PLACE] = ab_num_after(obuf, on, "VIOLATIONS=" as *u8) } }
  // 5th instrument: flat-file data-plane census (the store-law ruler, ecosystem-wide) -- rows banked
  // to the board's store (key=dataplanes) so the eat queue is store-served, never a flat twin.
  let x_dp: i64 = ab_exec_capture("./nx_dataplane_census.elf" as *u8, coredir, organdir, "logs/ab_dataplane.out" as *u8)
  on = ab_read_small("logs/ab_dataplane.out" as *u8, obuf, AB_OUTCAP)
  if x_dp == 0 { if on > 0 {
      mv[MV_DP] = ab_num_after(obuf, on, "FLAT-DATAPLANES pairs=" as *u8)
      ab_store_put("dataplanes" as *u8, obuf, on)
  } }
  ab_p("[dataplanes] census exit=" as *u8); ab_pn(x_dp)
  ab_p(" flat (organ,path) pairs=" as *u8); ab_pn(mv[MV_DP]); ab_p(" (rows: get dataplanes)\n" as *u8)
  // 3) zone map (disk truth) + the two inline metrics the rungs named
  let zoff: *i64 = sys_mmap(AB_ZSLOTS * 8) as *i64
  let zzone: *i64 = sys_mmap(AB_ZSLOTS * 8) as *i64
  let zlen: *i64 = sys_mmap(AB_ZSLOTS * 8) as *i64
  let zarena: *u8 = sys_mmap(AB_ZARENA)
  let aused: *i64 = sys_mmap(16) as *i64
  let ambig: *i64 = sys_mmap(16) as *i64
  aused[0] = 0; ambig[0] = 0
  var zi: i64 = 0
  while zi < AB_ZSLOTS { zoff[zi] = 0 - 1; zi = zi + 1 }
  let ncore: i64 = ab_scan_dir(coredir, 1, zoff, zzone, zlen, zarena, aused, ambig)
  let norgan: i64 = ab_scan_dir(organdir, 2, zoff, zzone, zlen, zarena, aused, ambig)
  ab_p("[zones] CORE(" as *u8); ab_p(coredir); ab_p(")=" as *u8); ab_pn(ncore)
  ab_p(" ORGAN(" as *u8); ab_p(organdir); ab_p(")=" as *u8); ab_pn(norgan)
  ab_p(" ambiguous-basenames=" as *u8); ab_pn(ambig[0]); ab_p("\n" as *u8)
  // visibility: CORE node importing an ORGAN node = boundary violation (base must not see app layer)
  let g: *EcoGraph = eg_load(store)
  if (g as i64) == 0 { ab_p("ARCH-BOARD RED: eco_graph store load failed\n" as *u8); return 1 }
  if ncore > 0 { if norgan > 0 {
      var viol: i64 = 0
      var shown: i64 = 0
      var u: i64 = 0
      while u < g.node_count {
          let uoff: i64 = g.node_off[u]
          var ul: i64 = 0
          while g.arena[uoff+ul] != (0 as u8) { ul = ul + 1 }
          if abz_get(zoff, zzone, zlen, zarena, g.arena, uoff, ul) == 1 {
              var p: i64 = g.out_head[u]
              while p < g.out_head[u+1] {
                  let v: i64 = g.out_list[p]
                  let voff: i64 = g.node_off[v]
                  var vl: i64 = 0
                  while g.arena[voff+vl] != (0 as u8) { vl = vl + 1 }
                  if abz_get(zoff, zzone, zlen, zarena, g.arena, voff, vl) == 2 {
                      viol = viol + 1
                      if shown < 32 { ab_p("  [visibility] CORE " as *u8); sys_write(1, ((g.arena as i64)+uoff) as *u8, ul); ab_p(" -> ORGAN " as *u8); sys_write(1, ((g.arena as i64)+voff) as *u8, vl); ab_p("\n" as *u8); shown = shown + 1 }
                  }
                  p = p + 1
              }
          }
          u = u + 1
      }
      mv[MV_VIS] = viol
  } }
  // validation depth: of the .nx files on disk (both zones), how many have a paired _test/_gate file?
  // HONEST SCOPE: counts PAIRED-FILE validators only (self-gating organs with a `gate` verb are not
  // counted) and the generated stub-family inflates the numerator -- the permille is a RATCHET floor,
  // not an absolute coverage claim.
  var subjects: i64 = 0
  var covered: i64 = 0
  let cand: *u8 = sys_mmap(160)
  zi = 0
  while zi < AB_ZSLOTS {
      if zoff[zi] >= 0 {
          let noff: i64 = zoff[zi]
          let nl: i64 = zlen[zi]
          let stem: i64 = nl - 3
          var isval: i64 = 0
          if ab_ends(zarena, noff, stem, "_test" as *u8) == 1 { isval = 1 }
          if ab_ends(zarena, noff, stem, "_gate" as *u8) == 1 { isval = 1 }
          if isval == 0 { if stem < 120 {
              subjects = subjects + 1
              var cvd: i64 = 0
              var w: i64 = 0
              while w < stem { cand[w] = zarena[noff+w]; w = w + 1 }
              var w2: i64 = ab_bapp(cand, stem, "_test.nx" as *u8)
              cand[w2] = 0 as u8
              if abz_get(zoff, zzone, zlen, zarena, cand, 0, w2) > 0 { cvd = 1 }
              if cvd == 0 {
                  w2 = ab_bapp(cand, stem, "_gate.nx" as *u8)
                  cand[w2] = 0 as u8
                  if abz_get(zoff, zzone, zlen, zarena, cand, 0, w2) > 0 { cvd = 1 }
              }
              covered = covered + cvd
          } }
      }
      zi = zi + 1
  }
  if subjects > 0 { mv[MV_VAL] = covered * 1000 / subjects }
  // base-change contract (advisory): FNV of the two sworn-interface files
  let fb: *u8 = sys_mmap(AB_OUTCAP)
  let pj: *u8 = sys_mmap(256)
  var pl: i64 = ab_bapp(pj, 0, coredir)
  pl = ab_bapp(pj, pl, "/nx_syscalls.nx" as *u8)
  pj[pl] = 0 as u8
  var fn1: i64 = ab_read_small(pj, fb, AB_OUTCAP)
  var h1: i64 = 0 - 1
  if fn1 > 0 { h1 = ab_fnv(fb, fn1) }
  pl = ab_bapp(pj, 0, coredir)
  pl = ab_bapp(pj, pl, "/nx_tier.nx" as *u8)
  pj[pl] = 0 as u8
  var fn2: i64 = ab_read_small(pj, fb, AB_OUTCAP)
  var h2: i64 = 0 - 1
  if fn2 > 0 { h2 = ab_fnv(fb, fn2) }
  if h1 >= 0 { if h2 >= 0 { mv[MV_BASEH] = (h1 ^ (h2 * AB_MAGIC_1000003)) & AB_MAGIC_4611686018427387903 } }
  // 4) policy + baseline (SOVEREIGN STORE keys, never flat files) -> judged rows
  let pnp: *i64 = sys_mmap(16) as *i64
  let pbuf: *u8 = ab_store_get("policy" as *u8, pnp)
  let pn: i64 = pnp[0]
  if pn <= 0 { ab_p("ARCH-BOARD RED: store key `policy` absent (knowledge/store/archboard-; seed: nx_arch_board put policy <staged-file>)\n" as *u8); return 1 }
  let bnp: *i64 = sys_mmap(16) as *i64
  var bbuf: *u8 = ab_store_get("baseline" as *u8, bnp)
  var bn: i64 = bnp[0]
  if bn < 0 { bn = 0; bbuf = sys_mmap(16); ab_p("[baseline] no banked key yet -- policy targets only (run `bank` after review to arm the ratchet)\n" as *u8) }
  // row arrays
  let r_no: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_nl: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_ro: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_rl: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_w: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_dir: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_tgt: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_cur: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_lim: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  let r_v: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  var nrow: i64 = 0
  var ls: i64 = 0
  var i: i64 = 0
  while i <= pn {
      var eol: i64 = 0
      if i >= pn { eol = 1 } else { if pbuf[i] == (10 as u8) { eol = 1 } }
      if eol == 1 {
          if i > ls { if pbuf[ls] != (35 as u8) { if nrow < AB_MAXROW {
              // metric|role|weight|direction|target
              var b1: i64 = 0 - 1
              var b2: i64 = 0 - 1
              var b3: i64 = 0 - 1
              var b4: i64 = 0 - 1
              var j: i64 = ls
              while j < i { if pbuf[j] == (124 as u8) { if b1 < 0 { b1 = j } else { if b2 < 0 { b2 = j } else { if b3 < 0 { b3 = j } else { if b4 < 0 { b4 = j } } } } } j = j + 1 }
              if b4 > 0 {
                  r_no[nrow] = ls; r_nl[nrow] = b1 - ls
                  r_ro[nrow] = b1 + 1; r_rl[nrow] = b2 - b1 - 1
                  r_w[nrow] = ab_num_at(pbuf, pn, b2 + 1)
                  var dc: i64 = 0
                  if pbuf[b3+1] == (108 as u8) { dc = 1 }
                  if pbuf[b3+1] == (103 as u8) { dc = 2 }
                  if pbuf[b3+1] == (99 as u8) { dc = 3 }
                  r_dir[nrow] = dc
                  r_tgt[nrow] = ab_num_at(pbuf, pn, b4 + 1)
                  let mi: i64 = ab_resolve(pbuf, r_no[nrow], r_nl[nrow])
                  var cur: i64 = 0 - 1
                  if mi >= 0 { cur = mv[mi] }
                  r_cur[nrow] = cur
                  let blv: *i64 = sys_mmap(16) as *i64
                  let hasbl: i64 = ab_bl_get(bbuf, bn, pbuf, r_no[nrow], r_nl[nrow], blv)
                  r_lim[nrow] = ab_limit(r_dir[nrow], r_tgt[nrow], hasbl, blv[0])
                  r_v[nrow] = ab_verdict(r_dir[nrow], r_tgt[nrow], hasbl, blv[0], cur)
                  sys_munmap(blv as *u8, 16)
                  nrow = nrow + 1
              }
          } } }
          ls = i + 1
      }
      i = i + 1
  }
  // 5) print judged rows + PM-ranked worklist + health; build the page alongside
  let page: *u8 = sys_mmap(AB_MAGIC_131072)
  var pp: i64 = 0
  pp = ab_bapp(page, pp, "<!-- self-emitted by nx_arch_board (census-sync law: the page cannot drift from the run) -->\n<title>Nishi Arch Board</title><h1>ARCH BOARD -- standing judgment of the family tree</h1>\n<table border=1 cellpadding=4><tr><th>role</th><th>metric</th><th>current</th><th>limit</th><th>weight</th><th>verdict</th></tr>\n" as *u8)
  var wsum: i64 = 0
  var wpass: i64 = 0
  var nred: i64 = 0
  var r: i64 = 0
  while r < nrow {
      ab_p("[" as *u8); sys_write(1, ((pbuf as i64)+r_ro[r]) as *u8, r_rl[r]); ab_p("] " as *u8)
      sys_write(1, ((pbuf as i64)+r_no[r]) as *u8, r_nl[r])
      ab_p(" = " as *u8); ab_pn(r_cur[r])
      ab_p(" (limit " as *u8); ab_pn(r_lim[r]); ab_p(", w" as *u8); ab_pn(r_w[r]); ab_p(") -> " as *u8)
      ab_p(ab_vname(r_v[r])); ab_p("\n" as *u8)
      wsum = wsum + r_w[r]
      if r_v[r] == AB_RED { nred = nred + 1 } else { wpass = wpass + r_w[r] }
      pp = ab_bapp(page, pp, "<tr><td>" as *u8)
      pp = ab_bappb(page, pp, pbuf, r_ro[r], r_rl[r])
      pp = ab_bapp(page, pp, "</td><td>" as *u8)
      pp = ab_bappb(page, pp, pbuf, r_no[r], r_nl[r])
      pp = ab_bapp(page, pp, "</td><td>" as *u8)
      pp = ab_bappn(page, pp, r_cur[r])
      pp = ab_bapp(page, pp, "</td><td>" as *u8)
      pp = ab_bappn(page, pp, r_lim[r])
      pp = ab_bapp(page, pp, "</td><td>" as *u8)
      pp = ab_bappn(page, pp, r_w[r])
      pp = ab_bapp(page, pp, "</td><td>" as *u8)
      pp = ab_bapp(page, pp, ab_vname(r_v[r]))
      pp = ab_bapp(page, pp, "</td></tr>\n" as *u8)
      r = r + 1
  }
  ab_p("--- PM-RANKED WORKLIST (momentum-weight desc; these rows ARE the priorities) ---\n" as *u8)
  pp = ab_bapp(page, pp, "</table><h2>PM-ranked worklist</h2><ol>\n" as *u8)
  let done: *i64 = sys_mmap(AB_MAXROW*8) as *i64
  var d: i64 = 0
  while d < nrow { done[d] = 0; d = d + 1 }
  var emitted: i64 = 0
  var pass_n: i64 = 0
  while pass_n < nrow {
      var best: i64 = 0 - 1
      var bi: i64 = 0
      while bi < nrow {
          if done[bi] == 0 { if r_v[bi] != AB_PASS { if best < 0 { best = bi } else { if r_w[bi] > r_w[best] { best = bi } } } }
          bi = bi + 1
      }
      if best >= 0 {
          done[best] = 1
          ab_p("  w" as *u8); ab_pn(r_w[best]); ab_p(" [" as *u8)
          sys_write(1, ((pbuf as i64)+r_ro[best]) as *u8, r_rl[best]); ab_p("] " as *u8)
          sys_write(1, ((pbuf as i64)+r_no[best]) as *u8, r_nl[best])
          ab_p(" cur=" as *u8); ab_pn(r_cur[best]); ab_p(" limit=" as *u8); ab_pn(r_lim[best])
          ab_p(" -> " as *u8); ab_p(ab_vname(r_v[best])); ab_p("\n" as *u8)
          pp = ab_bapp(page, pp, "<li>w" as *u8)
          pp = ab_bappn(page, pp, r_w[best])
          pp = ab_bapp(page, pp, " [" as *u8)
          pp = ab_bappb(page, pp, pbuf, r_ro[best], r_rl[best])
          pp = ab_bapp(page, pp, "] " as *u8)
          pp = ab_bappb(page, pp, pbuf, r_no[best], r_nl[best])
          pp = ab_bapp(page, pp, " -> " as *u8)
          pp = ab_bapp(page, pp, ab_vname(r_v[best]))
          pp = ab_bapp(page, pp, "</li>\n" as *u8)
          emitted = emitted + 1
      } else { pass_n = nrow }
      pass_n = pass_n + 1
  }
  if emitted == 0 { ab_p("  (empty -- every judged axis is at or better than its ratchet)\n" as *u8); pp = ab_bapp(page, pp, "<li>(empty -- all axes at or better than ratchet)</li>\n" as *u8) }
  var health: i64 = 0
  if wsum > 0 { health = wpass * 1000 / wsum }
  ab_p("--- BOARD: rows=" as *u8); ab_pn(nrow)
  ab_p(" health=" as *u8); ab_pn(health)
  ab_p("/1000 RED=" as *u8); ab_pn(nred)
  if nred == 0 { ab_p(" verdict=GREEN (ratchet intact)\n" as *u8) } else { ab_p(" verdict=RED (regression or instrument failure -- eat before feature work, per the eat-debt law)\n" as *u8) }
  pp = ab_bapp(page, pp, "</ol><h2>Verdict: " as *u8)
  if nred == 0 { pp = ab_bapp(page, pp, "GREEN" as *u8) } else { pp = ab_bapp(page, pp, "RED" as *u8) }
  pp = ab_bapp(page, pp, " -- health " as *u8)
  pp = ab_bappn(page, pp, health)
  pp = ab_bapp(page, pp, "/1000</h2>\n" as *u8)
  ab_write_file("knowledge/arch_board.html" as *u8, page, pp)
  ab_p("[page] knowledge/arch_board.html emitted (" as *u8); ab_pn(pp); ab_p(" bytes)\n" as *u8)
  // 6) bank (atomic, refuses on any instrument failure)
  if do_bank == 1 {
      var anyfail: i64 = 0
      r = 0
      while r < nrow { if r_cur[r] < 0 { anyfail = 1 } r = r + 1 }
      if anyfail == 1 { ab_p("BANK REFUSED: an instrument failed (cur<0) -- never bank a broken measurement (fail-safe)\n" as *u8); return 4 }
      let bl2: *u8 = sys_mmap(AB_MAGIC_16384)
      var bp: i64 = ab_bapp(bl2, 0, "# archboard store key=baseline -- banked by nx_arch_board bank; the ratchet: limits tighten to these\n" as *u8)
      r = 0
      while r < nrow {
          bp = ab_bappb(bl2, bp, pbuf, r_no[r], r_nl[r])
          bp = ab_bapp(bl2, bp, "|" as *u8)
          bp = ab_bappn(bl2, bp, r_cur[r])
          bp = ab_bapp(bl2, bp, "\n" as *u8)
          r = r + 1
      }
      if ab_store_put("baseline" as *u8, bl2, bp) == 0 {
          ab_p("[bank] baseline banked to the SOVEREIGN STORE (key=baseline, " as *u8); ab_pn(nrow); ab_p(" metrics; seg-commit atomic) -- the ratchet is armed at today's truth\n" as *u8)
      } else { ab_p("[bank] STORE PUT FAILED -- baseline unchanged (fail-safe)\n" as *u8); return 4 }
  }
  if nred == 0 { return 0 }
  return 1
742}
743
744// ---- validation WORKLIST emitter (the w22 rung as a CONSUMABLE QUEUE, not a campaign): every disk-present
745// organ lacking a paired _test/_gate, ranked by graph fan-in (risk = how many organs depend on the ungated
746// one). Emits knowledge/registry/validation_worklist.data rows `fanin|name` (top 200) -- the forge/team's
747// inbound queue; the PM eats from the top. ----
748func ab_worklist(store: *u8, coredir: *u8, organdir: *u8) -> i64 {
  let g: *EcoGraph = eg_load(store)
  if (g as i64) == 0 { ab_p("worklist: store load failed\n" as *u8); return 1 }
  let zoff: *i64 = sys_mmap(AB_ZSLOTS * 8) as *i64
  let zzone: *i64 = sys_mmap(AB_ZSLOTS * 8) as *i64
  let zlen: *i64 = sys_mmap(AB_ZSLOTS * 8) as *i64
  let zarena: *u8 = sys_mmap(AB_ZARENA)
  let aused: *i64 = sys_mmap(16) as *i64
  let ambig: *i64 = sys_mmap(16) as *i64
  aused[0] = 0; ambig[0] = 0
  var zi: i64 = 0
  while zi < AB_ZSLOTS { zoff[zi] = 0 - 1; zi = zi + 1 }
  ab_scan_dir(coredir, 1, zoff, zzone, zlen, zarena, aused, ambig)
  ab_scan_dir(organdir, 2, zoff, zzone, zlen, zarena, aused, ambig)
  // candidates: graph nodes present on disk, not themselves validators, with no paired validator
  let cfan: *i64 = sys_mmap((g.node_count + 2) * 8) as *i64
  let cidx: *i64 = sys_mmap((g.node_count + 2) * 8) as *i64
  var nc: i64 = 0
  let cand: *u8 = sys_mmap(160)
  var i: i64 = 0
  while i < g.node_count {
      let off: i64 = g.node_off[i]
      var l: i64 = 0
      while g.arena[off+l] != (0 as u8) { l = l + 1 }
      if abz_get(zoff, zzone, zlen, zarena, g.arena, off, l) > 0 { if l > 3 { if l < 120 {
          let stem: i64 = l - 3
          var isval: i64 = 0
          if ab_ends(g.arena, off, stem, "_test" as *u8) == 1 { isval = 1 }
          if ab_ends(g.arena, off, stem, "_gate" as *u8) == 1 { isval = 1 }
          if isval == 0 {
              var w: i64 = 0
              while w < stem { cand[w] = g.arena[off+w]; w = w + 1 }
              var cv: i64 = 0
              var w2: i64 = ab_bapp(cand, stem, "_test.nx" as *u8)
              if abz_get(zoff, zzone, zlen, zarena, cand, 0, w2) > 0 { cv = 1 }
              if cv == 0 { w2 = ab_bapp(cand, stem, "_gate.nx" as *u8); if abz_get(zoff, zzone, zlen, zarena, cand, 0, w2) > 0 { cv = 1 } }
              if cv == 0 { cfan[nc] = g.in_head[i+1] - g.in_head[i]; cidx[nc] = i; nc = nc + 1 }
          }
      } } }
      i = i + 1
  }
  // emit top 200 by fan-in (selection; ties keep first)
  let out: *u8 = sys_mmap(AB_MAGIC_65536)
  var op: i64 = ab_bapp(out, 0, "# archboard store key=worklist -- ungated organs ranked by fan-in (risk); emitted by nx_arch_board worklist.\n# Consume from the top: gate the organs the most of the ecosystem depends on. rows: fanin|name\n" as *u8)
  var emitted: i64 = 0
  while emitted < 200 {
      var best: i64 = 0 - 1
      var bi: i64 = 0
      while bi < nc { if cfan[bi] >= 0 { if best < 0 { best = bi } else { if cfan[bi] > cfan[best] { best = bi } } } bi = bi + 1 }
      if best < 0 { emitted = 200 } else {
          op = ab_bappn(out, op, cfan[best])
          op = ab_bapp(out, op, "|" as *u8)
          let boff: i64 = g.node_off[cidx[best]]
          var bl: i64 = 0
          while g.arena[boff+bl] != (0 as u8) { bl = bl + 1 }
          op = ab_bappb(out, op, g.arena, boff, bl)
          op = ab_bapp(out, op, "\n" as *u8)
          cfan[best] = 0 - 1
          emitted = emitted + 1
      }
  }
  if ab_store_put("worklist" as *u8, out, op) == 0 {
      ab_p("worklist: " as *u8); ab_pn(nc); ab_p(" ungated organs; top-200 by fan-in -> SOVEREIGN STORE knowledge/store/archboard- key=worklist (the forge/team inbound queue; read: nx_arch_board get worklist)\n" as *u8)
      return 0
  }
  ab_p("worklist: STORE PUT FAILED\n" as *u8)
  return 1
815}
816
817func main(argc: i64, argv: *i64) -> i64 {
  // self-locating (cron-safe): chdir to the directory of our own ELF so every relative path
  // (instruments, knowledge/, logs/) resolves from the nishihost home regardless of caller cwd --
  // lets the cron row keep the sworn absolute-/nishihost/-binary shape the reconciler's taint
  // rule requires, with no wrapper script.
  let sp: *u8 = sys_mmap(512)
  let sl: i64 = sys_readlinkat("/proc/self/exe" as *u8, sp, 511)
  if sl > 0 {
      var cut: i64 = 0 - 1
      var si: i64 = 0
      while si < sl { if sp[si] == (47 as u8) { cut = si } si = si + 1 }
      if cut > 0 { sp[cut] = 0 as u8; sys_chdir(sp) }
  }
  if argc < 2 { return ab_gate() }
  let verb: *u8 = argv[1] as *u8
  if ab_streq(verb, "gate" as *u8) == 1 { return ab_gate() }
  var core: *u8 = "buildroot/runtime" as *u8
  var organ: *u8 = "buildroot/runtime/_hdl_build" as *u8
  if argc >= 4 { core = argv[3] as *u8 }
  if argc >= 5 { organ = argv[4] as *u8 }
  if ab_streq(verb, "run" as *u8) == 1 {
      if argc < 3 { ab_p("usage: nx_arch_board run <store-prefix> [core-dir] [organ-dir]\n" as *u8); return 2 }
      return ab_run(argv[2] as *u8, core, organ, 0)
  }
  if ab_streq(verb, "bank" as *u8) == 1 {
      if argc < 3 { ab_p("usage: nx_arch_board bank <store-prefix> [core-dir] [organ-dir]\n" as *u8); return 2 }
      return ab_run(argv[2] as *u8, core, organ, 1)
  }
  if ab_streq(verb, "worklist" as *u8) == 1 {
      if argc < 3 { ab_p("usage: nx_arch_board worklist <store-prefix> [core-dir] [organ-dir]\n" as *u8); return 2 }
      return ab_worklist(argv[2] as *u8, core, organ)
  }
  // sovereign-store operator interface: policy/fixture updates stage a file then `put`; any
  // consumer (forge, PM, human) reads via `get` -- the STORE is the only SSOT, no flat twins.
  if ab_streq(verb, "put" as *u8) == 1 {
      if argc < 4 { ab_p("usage: nx_arch_board put <key> <staged-file>\n" as *u8); return 2 }
      let vb: *u8 = sys_mmap(AB_MAGIC_1048576)
      let vn: i64 = ab_read_small(argv[3] as *u8, vb, AB_MAGIC_1048576)
      if vn <= 0 { ab_p("put: staged file unreadable/empty\n" as *u8); return 3 }
      if ab_store_put(argv[2] as *u8, vb, vn) == 0 { ab_p("put OK: key=" as *u8); ab_p(argv[2] as *u8); ab_p(" bytes=" as *u8); ab_pn(vn); ab_p(" (seg-commit atomic)\n" as *u8); return 0 }
      ab_p("put FAILED\n" as *u8)
      return 3
  }
  if ab_streq(verb, "get" as *u8) == 1 {
      if argc < 3 { ab_p("usage: nx_arch_board get <key>\n" as *u8); return 2 }
      let glp2: *i64 = sys_mmap(16) as *i64
      let gb2: *u8 = ab_store_get(argv[2] as *u8, glp2)
      if glp2[0] < 0 { ab_p("get: key absent\n" as *u8); return 3 }
      sys_write(1, gb2, glp2[0])
      return 0
  }
  ab_p("usage: nx_arch_board gate | run <store> [core organ] | bank <store> [core organ] | worklist <store> [core organ] | put <key> <file> | get <key>\n" as *u8)
  return 2
870}
nx_arch_board.nx source

`nx_arch_board.nx` source
